{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 基于PINN的CFD离散网格优化——三维三维室内气流结构\n",
    "\n",
    "## 一、引言\n",
    "计算流体力学（CFD）是21世纪流体力学领域的重要技术之一，使用数值方法在计算机中对流体力学的控制方程进行求解，从而可预测流场的流动。目前有多种成熟的CFD软件，比如FLUENT、Star-CD、OpenFoam、CFX等。为了求解流体力学的控制方程，一个必要的前提是有适合数值方法的离散网格。生成离散网格的软件也有多种，比如ICEM、GAMBIT、ANSYS、Star-CD等。离散网格的质量（Quality）是影响CFD求解的关键因素。但是在传统的CFD流程中，离散网格的生成仅有一些指导经验。为了生成一个高质量的离散网格，往往需要对CFD求解结果进行网格敏感性分析（Mesh Sensitiviy Study）。这是一个耗时且无法跳过的过程。\n",
    "\n",
    "近年来基于物理信息约束神经元网络（PINN）的方法在流体力学领域较为流行。PINN的特色是在神经元网络的损失函数（Loss Function）里包含流体力学的控制方程，使得神经元网络可以代替CFD的求解过程。对比CFD软件，PINN的求解速度较快，一部分是因为PINN对CFD流程的简化，另一部分是因为PINN的计算是在GPU上进行。但是，目前PINN求解精度还有待提高。\n",
    "\n",
    "本课题的目的是基于PINN进行CFD离散网格优化，即并不采用PINN代替高精度的CFD求解器，而是用PINN的求解速度快以及其具备一定的求解精度的特点，加快寻找最优的离散网格，从而缩短整体CFD流程的速度。本质上，本课题是为了验证一个假说，即高质量的离散网格，也对应相对高精度的PINN。\n",
    "\n",
    "本课题旨在利用基于PINN的方法进行CFD离散网格优化，以加快整体CFD流程的速度。通过利用PINN的快速求解和一定的求解精度，我们希望找到最优的离散网格。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 二、设计思路与实现方案\n",
    "本问题是三维室内空气流动问题，根据比赛方给的文件，我们将问题简化为三维关于Z方向对称的流动问题。控制方程为三维不可压缩的Navier-Stokes 方程。\n",
    "\n",
    "Navier-Stokes方程，它描述了流体的运动行为，这里的流体当然也包括本案例研究的空气流动。Navier-Stokes方程是流体力学中的基本方程之一，用于描述流体的速度和压力之间的关系。室内流动通常涉及复杂的流体行为，例如空气在房间内的流动、热对流、湍流等。Navier-Stokes方程提供了描述这些流动行为的数学模型。\n",
    "\n",
    "在三维情况下，Navier-Stokes方程可以写成以下形式：\n",
    "\n",
    "$$\n",
    "\\frac{{\\partial \\mathbf{u}}}{{\\partial t}} + (\\mathbf{u} \\cdot \\nabla) \\mathbf{u} = -\\frac{1}{\\rho} \\nabla p + \\nu \\nabla^2 \\mathbf{u} + \\mathbf{f}\n",
    "$$\n",
    "\n",
    "其中，\n",
    "\n",
    "- $\\mathbf{u}$ 是流体的速度矢量；\n",
    "- $t$ 是时间；\n",
    "- $\\rho$ 是流体的密度；\n",
    "- $p$ 是流体的压力；\n",
    "- $\\nu$ 是运动粘度（动力粘度）；\n",
    "- $\\nabla$ 是梯度算子（向量的梯度）；\n",
    "- $\\nabla^2$ 是拉普拉斯算子（向量的散度的梯度）；\n",
    "- $\\mathbf{f}$ 是外力（例如重力、浮力等）。\n",
    "\n",
    "这个方程可以分为两部分：左侧是速度项，右侧是压力梯度项、粘性项和外力项。\n",
    "\n",
    "\n",
    "### 2.1 设计思路\n",
    "本设计方案参考官方给出的RFC优化流程，如图所示\n",
    "![](https://ai-studio-static-online.cdn.bcebos.com/5bbd2fddd3544502afa0706ce1745f95d839dbafe78c433aaaa6adf4fcdf2e4c)\n",
    "Level表示优化的层级，Points/Nodes表示训练点集或者网格的节点，Mesh代表三角形或者四面体网格，CFD solutions为传统CFD得到的参考解。注意，这里的CFD solution是否调用是可自由选择的，故在图中使用虚线来表示，可以根据实际训练情况灵活地选择是否使用CFD数据来进行无监督学习（无CFD数据)或监督学习（有CFD数据)。初始分为两类情况，一种是已有来自于其他网格生成工具的粗糙的初始网格构型，另一种是直接在计算域中随机采样训练点来进行三角化/四面体化来生成网格。对应图中N1和M1的相互转换。\n",
    "### 2.2 实现方案\n",
    "在优化之前，我们使用CFD软件Fluent得到一个高分辨率的CFD解作为参考。根据优化流程，本方案的流程如下：\n",
    "#### Level 1\n",
    "1. 读取官方给定的msh文件，转化成离散点，作为可供PINNs可训练的点集；\n",
    "2. 利用相同的网格结构, 计算CFD, 得到标签数据，即速度（三个方向）、压力；\n",
    "3. 利用PINNs训练，loss为CFD的标签，即三个方向的速度和压力。\n",
    "4. 对网格进行加密：我们利用每一个网格的质心计算的Navier-Stokes方程的pde残差大小来判断网格是否需要加密。选取残差较大的一部分网格进行加密。\n",
    "5. 对加密完后的网格重新计算CFD，得到新的解，以及新的标签数据用于下个level。\n",
    "\n",
    "#### Leve N\n",
    "在level 1之后，每一个level都是利用上一个level 加密后的新点集以及新的标签数据重复进行level 1的所有步骤。按照比赛方的验收标准，我们认为当室内高度方向中心面及长度方向中心面交线的速度幅值收敛后，网格加密完成。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 三、优化流程\n",
    "本章中，我们将展示优化三维室内流动的网格的全过程。一共3个优化过程，包含4个level和4次CFD的计算。我们用到的库有meshio, numpy, scipy等库。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-12-01T08:53:48.125386Z",
     "iopub.status.busy": "2023-12-01T08:53:48.124739Z",
     "iopub.status.idle": "2023-12-01T08:53:59.478098Z",
     "shell.execute_reply": "2023-12-01T08:53:59.476991Z",
     "shell.execute_reply.started": "2023-12-01T08:53:48.125347Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Looking in indexes: https://mirror.baidu.com/pypi/simple/, https://mirrors.aliyun.com/pypi/simple/, https://pypi.tuna.tsinghua.edu.cn/simple/\r\n",
      "Collecting meshio\r\n",
      "  Downloading https://mirrors.aliyun.com/pypi/packages/42/0d/e6fb61a615ce1ab5548894dde1efdb22232213a84da671b6314255ba0cfe/meshio-5.3.4-py3-none-any.whl (167 kB)\r\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m167.7/167.7 kB\u001b[0m \u001b[31m1.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\r\n",
      "\u001b[?25hRequirement already satisfied: numpy in /opt/conda/envs/python35-paddle120-env/lib/python3.10/site-packages (from meshio) (1.26.1)\r\n",
      "Requirement already satisfied: rich in /opt/conda/envs/python35-paddle120-env/lib/python3.10/site-packages (from meshio) (13.6.0)\r\n",
      "Requirement already satisfied: markdown-it-py>=2.2.0 in /opt/conda/envs/python35-paddle120-env/lib/python3.10/site-packages (from rich->meshio) (2.2.0)\r\n",
      "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /opt/conda/envs/python35-paddle120-env/lib/python3.10/site-packages (from rich->meshio) (2.16.1)\r\n",
      "Requirement already satisfied: mdurl~=0.1 in /opt/conda/envs/python35-paddle120-env/lib/python3.10/site-packages (from markdown-it-py>=2.2.0->rich->meshio) (0.1.1)\r\n",
      "Installing collected packages: meshio\r\n",
      "Successfully installed meshio-5.3.4\r\n",
      "Looking in indexes: https://mirror.baidu.com/pypi/simple/, https://mirrors.aliyun.com/pypi/simple/, https://pypi.tuna.tsinghua.edu.cn/simple/\r\n",
      "Collecting meshpy\r\n",
      "  Downloading https://mirrors.aliyun.com/pypi/packages/70/87/9b8b6eea09dcd890b656d9ad4ed0870a1f71a871af9e1b804cea4fe3978c/MeshPy-2022.1.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (458 kB)\r\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m459.0/459.0 kB\u001b[0m \u001b[31m1.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\r\n",
      "\u001b[?25hCollecting pyvtk\r\n",
      "  Downloading https://mirrors.aliyun.com/pypi/packages/f8/5b/0b0d98847afc04f2e330cefa3d076ee08d6ad162870f8e742496c191bdfd/PyVTK-0.5.18.zip (31 kB)\r\n",
      "  Preparing metadata (setup.py) ... \u001b[?25ldone\r\n",
      "\u001b[?25hCollecting pytools>=2011.2 (from meshpy)\r\n",
      "  Downloading https://mirrors.aliyun.com/pypi/packages/3d/4b/4cbe808b38ee25d3c3f1b1b99bde39cef43c30df64416b62e28079404d1b/pytools-2023.1.1-py2.py3-none-any.whl (70 kB)\r\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m70.6/70.6 kB\u001b[0m \u001b[31m1.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\r\n",
      "\u001b[?25hRequirement already satisfied: numpy in /opt/conda/envs/python35-paddle120-env/lib/python3.10/site-packages (from meshpy) (1.26.1)\r\n",
      "Collecting gmsh-interop (from meshpy)\r\n",
      "  Downloading https://mirrors.aliyun.com/pypi/packages/72/b0/79829dd4fd5745b859d3314f5b1854e609929107655d2da6cc4b317e3375/gmsh_interop-2021.1.1.tar.gz (24 kB)\r\n",
      "  Preparing metadata (setup.py) ... \u001b[?25ldone\r\n",
      "\u001b[?25hRequirement already satisfied: six in /opt/conda/envs/python35-paddle120-env/lib/python3.10/site-packages (from pyvtk) (1.16.0)\r\n",
      "Requirement already satisfied: platformdirs>=2.2.0 in /opt/conda/envs/python35-paddle120-env/lib/python3.10/site-packages (from pytools>=2011.2->meshpy) (3.11.0)\r\n",
      "Requirement already satisfied: typing-extensions>=4.0 in /opt/conda/envs/python35-paddle120-env/lib/python3.10/site-packages (from pytools>=2011.2->meshpy) (4.8.0)\r\n",
      "Building wheels for collected packages: pyvtk, gmsh-interop\r\n",
      "  Building wheel for pyvtk (setup.py) ... \u001b[?25ldone\r\n",
      "\u001b[?25h  Created wheel for pyvtk: filename=PyVTK-0.5.18-py3-none-any.whl size=24734 sha256=897aa45ef76f32e582a9340bf4c4632b8afb849d12aeb33b21e0d9ae03c7639d\r\n",
      "  Stored in directory: /home/aistudio/.cache/pip/wheels/0e/2f/18/84e9027e6351e76ca8b21ba3bb40df8f34ba3b7c7c81c81932\r\n",
      "  Building wheel for gmsh-interop (setup.py) ... \u001b[?25ldone\r\n",
      "\u001b[?25h  Created wheel for gmsh-interop: filename=gmsh_interop-2021.1.1-py2.py3-none-any.whl size=21976 sha256=e0c471d5d7c72f92bf8b4f3732d546cfcefc17e92c8a55cc7904564a684257d4\r\n",
      "  Stored in directory: /home/aistudio/.cache/pip/wheels/f9/66/55/5387d5dde8852fc0555d63f56dcd3b6e5f4abe7df61224c925\r\n",
      "Successfully built pyvtk gmsh-interop\r\n",
      "Installing collected packages: pyvtk, pytools, gmsh-interop, meshpy\r\n",
      "Successfully installed gmsh-interop-2021.1.1 meshpy-2022.1.3 pytools-2023.1.1 pyvtk-0.5.18\r\n"
     ]
    }
   ],
   "source": [
    "#更新下pip,安装meshio\n",
    "!pip install --upgrade pip\n",
    "!pip install meshio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-12-01T14:24:14.415553Z",
     "iopub.status.busy": "2023-12-01T14:24:14.414918Z",
     "iopub.status.idle": "2023-12-01T14:24:16.876743Z",
     "shell.execute_reply": "2023-12-01T14:24:16.875761Z",
     "shell.execute_reply.started": "2023-12-01T14:24:14.415521Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import meshio\n",
    "from scipy.spatial import Delaunay\n",
    "from meshpy.tet import MeshInfo, build, Options\n",
    "import sys \n",
    "import work.src.pinns as pinns\n",
    "import work.src.utils as utils\n",
    "import pandas as pd\n",
    "import paddle\n",
    "import paddle.nn as nn\n",
    "\n",
    "# device = paddle.set_device('cpu') \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-12-01T14:24:53.254977Z",
     "iopub.status.busy": "2023-12-01T14:24:53.254453Z",
     "iopub.status.idle": "2023-12-01T14:24:53.259135Z",
     "shell.execute_reply": "2023-12-01T14:24:53.258230Z",
     "shell.execute_reply.started": "2023-12-01T14:24:53.254948Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Train or read existing models\n",
    "tag_train = False\n",
    "# tag_train = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1 Level 1的优化过程\n",
    "#### 3.1.1 处理初始网格"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-12-01T14:11:20.544378Z",
     "iopub.status.busy": "2023-12-01T14:11:20.543529Z",
     "iopub.status.idle": "2023-12-01T14:11:20.778126Z",
     "shell.execute_reply": "2023-12-01T14:11:20.777289Z",
     "shell.execute_reply.started": "2023-12-01T14:11:20.544347Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "mesh = meshio.read('work/progress/level_01/mesh_files/room.msh', file_format='ansys')\n",
    "# process mesh form original .msh file, the file_format is ansys, then output the mesh as .vtk file\n",
    "utils.process_mesh(mesh)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.1.2 读取网格"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-12-01T14:24:41.529388Z",
     "iopub.status.busy": "2023-12-01T14:24:41.528796Z",
     "iopub.status.idle": "2023-12-01T14:24:41.639743Z",
     "shell.execute_reply": "2023-12-01T14:24:41.638686Z",
     "shell.execute_reply.started": "2023-12-01T14:24:41.529358Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Setting the level and the next level\n",
    "level, level_next = 'level_01', 'level_02'\n",
    "# read mesh form the last vtk file\n",
    "mesh = meshio.read(f'work/progress/{level}/mesh_files/{level}.vtk', file_format='vtk')\n",
    "points = mesh.points\n",
    "# Delaunay tetrahedralization\n",
    "# points Enter scatter points; furthest_site is True to compute the furthest point; incremental is True to allow incremental addition of points; qhull_options is the qhull parameter\n",
    "tri = Delaunay(points, furthest_site=False, incremental=False, qhull_options=None)\n",
    "# get vertices and tetrahedrons\n",
    "vertices = tri.points\n",
    "tetrahedrons = tri.simplices\n",
    "# find the center point in each tetrahedron\n",
    "central_points_origin = utils.find_center_in_tetrahedron(tetrahedrons, vertices)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.1.3 将CFD数据转化成张量, 利用Paddle训练\n",
    "网络结构为40*4，使用Adam优化器，训练20万个epoch,学习率为余弦递减"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-12-01T14:24:57.476042Z",
     "iopub.status.busy": "2023-12-01T14:24:57.474863Z",
     "iopub.status.idle": "2023-12-01T14:24:57.496512Z",
     "shell.execute_reply": "2023-12-01T14:24:57.495482Z",
     "shell.execute_reply.started": "2023-12-01T14:24:57.476010Z"
    },
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "load start epoch at 199835\r\n"
     ]
    }
   ],
   "source": [
    "# read data from cfd result\n",
    "datas_from_cfd = pd.read_csv(f'work/progress/{level}/cfd_labels/{level}_labels_from_cfd.dat').values\n",
    "# x, y, p, rho, u, v = np.array([datas_from_cfd[:,i+1] for i in range(6)])\n",
    "xyz_and_labels = datas_from_cfd[:,1:]\n",
    "x_pde_train, label = utils.to_tensor(xyz_and_labels)\n",
    "# model\n",
    "Net = pinns.DNN_single(depth=4, width=40, active = nn.Tanh())\n",
    "# we use adam opt, with deacy learning rate from 1e-3. cosine annealing strategies to dynamically adjust the learning rate. The deatils see work.src.pinns\n",
    "if tag_train:\n",
    "    pinns.train(Net, x_pde_train,label, best_loss=1e2, opt = 'Adam', epoches=200000, lr=1e-3, step=1, progress_path=f'work/progress/{level}')\n",
    "else:\n",
    "    Net.loadmodel(f\"work/progress/{level}/model_paras/ns.pdparams\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-12-01T14:25:00.825708Z",
     "iopub.status.busy": "2023-12-01T14:25:00.825199Z",
     "iopub.status.idle": "2023-12-01T14:25:02.965227Z",
     "shell.execute_reply": "2023-12-01T14:25:02.964471Z",
     "shell.execute_reply.started": "2023-12-01T14:25:00.825680Z"
    },
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x800 with 8 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "'''visualize the velocity and pressure using neural network'''\n",
    "pinns.show_slice_uvwp(Net, xyz_and_labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.1.4 对NS方程的残差进行排序\n",
    "计算网格的优劣是依据网格的NS方程残差大小，因此当模型训练好之后，需要利用PDE来前向传播计算Loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-12-01T14:13:59.334995Z",
     "iopub.status.busy": "2023-12-01T14:13:59.334488Z",
     "iopub.status.idle": "2023-12-01T14:14:00.607023Z",
     "shell.execute_reply": "2023-12-01T14:14:00.606139Z",
     "shell.execute_reply.started": "2023-12-01T14:13:59.334964Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxgAAAMWCAYAAABydyAUAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd3wjZ53/PzNqlmQV97pre3tLtmezXpKQhDRCSchBQo7Q69HhB3eUcHRIILTjLtQDAgRCQhKSHCQkhPSerHtZ926vbUku6jPz/P54PLOSLNmSLduS/X2/XvuC2CqPxjOj7+f5lo/AGGMgCIIgCIIgCIJIA+JaL4AgCIIgCIIgiPUDCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIAiCIAiCINIGCQyCIDYkjLG1XgJBEARBrEv0a70AgiCI1URRFIRCIQSDQRgMBuj1euh0OoiiCEEQ1np5BEEQBJH1CIy28QiC2AAwxiDLMiRJgiRJCIVCEAQBjDGIoghRFKHX60lwEARBEMQyIYFBEMS6hzGGcDgMWZaj/lsURTDGwBiDoija471eLwRBQF5eHgkOgiAIgkgRKpEiCGJdI8sywuEwFEXRRIIqNABAEAQIggBR5C1pjDGMjY2BMQaLxYJgMAhBEKDT6TSxodfrtecRBEEQBBENCQyCINYljDFIkoTOzk4oioKtW7dqgkDNWsRDFRuKokCv12uPlSQJ4XBYExaq0FBFBwkOgiAIguCQwCAIYt2hKAokSYIsywgGg2CMpRz8qwIkXoYjkeAwGAzQ6XRaSRVBEARBbERIYBAEsW5QeynC4bAmKkRRhCRJUY8bHx+H1+tFfn4+rFbrPPGxkBhJVnBEZjdIcBAEQRAbCRIYBEGsC2IbudVAX50UBQCSJKG1tRVjY2PIzc1Fd3c3dDod8vLykJeXB6fTCYvFEvWcxUgkOMLhMEKhEADMm1BFgoMgCIJYz5DAIAgi61GzFrIsz5v2pP7/mZkZ1NXVwWg04txzz9X6Jqanp+F2uzE2NoaOjg7o9XrNH8Pn88FsNqdUXrWY4KAMB0EQBLHeoTG1BEFkLZHeFpFToiLp6OjAxMQEZmdnUV1dja1bt2qCRKfTRT1WlmVMT0+jp6cHXq8XkiTBaDRqGY68vDzk5OQse82KokRlSGIFhzqliiAIgiCyERIYBEFkJYlKoiIJhUJ4/vnn4ff7cfjwYRQUFACA1i8RKzBUent74fP5sHPnTng8Hng8HrjdbszMzMBkMkUJDpPJtOzPoQqOyL6ReFOqCIIgCCIboBIpgiCyDkVREAqFEmYtAMDtdqO+vh46nQ5FRUWauAAWbuJWYYxBp9OhoKAgSpiogmNgYAAtLS2wWCxwOp2a4DAajSl9FnUCVeT7qhkWtaRKFRyRU6pIcBAEQRCZCgkMgiCyBrUkSp0SFU9cMMbQ1dWFnp4ebN++HYqiYHp6OqX3SdTkrdfrUVhYiMLCQgBAOBzWBEdfXx+am5thtVq1hvG8vDwYDIaU31sVHOoa4gmO2B4OEhwEQRBEpkACgyCIrCDS2wJAXHERCATQ0NCAQCCAY8eOwW63o6enZ55YWCwYTzZYNxgMKCoqQlFREQBekqWWU/X09KCpqQm5ubma4HA6nSkJDnUd8QRHKBTSXMZJcBAEQRCZBAkMgiAymnjeFvGC59OnT6OxsRFFRUU4dOgQ9Hp+e0tl5KzKUp4DAEajEcXFxSguLgbABYfb7Ybb7UZXVxd8Ph9sNluU4FDXmey6gMSCY6GxuCQ4CIIgiNWCBAZBEBmLamCnGuXFExeKoqC9vR2Dg4PYu3cvysvLo36fSCwsFnCnY/6F0WhESUkJSkpKAADBYFATHKdOnUIwGNQER15eHhwOR8LG83jEExzqv2AwSIKDIAiCWBNIYBAEkZFEeltE+kpE4vV6UV9fDwCora2F1Wqd95ilBNIrFXybTCaUlpaitLQUAOD3+7WSqtbWVoRCIdjtdk1w2O32lAVHpOiIFRyRJVWq14fqwUGCgyAIgkgXJDAIgsgokvG2AIChoSG0tLSgsrISO3fuTGhUt5olUqliNpthNptRVlYGxliU4BgeHoYkSfMERyqGfAsJjkAgoD2GBAdBEASRTkhgEASRMcR6W8QLdCVJQktLC8bHx7F//36t3yERSxULq20RJAgCLBYLLBYLysvLwRiDz+fTBMfg4CBkWYbD4dAEh81mWxHBEevBQYKDIAiCSAUSGARBZATJeFtMTU2hvr4eOTk5OHHiRFKu2pmcwVhsDVarFVarFRUVFWCMwev1wu12w+PxoL+/H4wxrVlcFRypCIFEgkNRFMzMzKC1tRX79+8nwUEQBEGkBAkMgiDWlGS9Lfr6+tDR0YEtW7Zgy5YtSQe4SxUYmYYgCMjNzUVubi42bdoExhhmZ2c1wdHb2wtBEKIER25u7pIFh16vx9TUFABAlmXIsoxAIABRFOc1jZPgIAiCICIhgUEQxJqRTElUKBRCY2MjZmZmcOTIEeTl5S3pfVbjOauJIAiw2Wyw2WzYvHkzGGOYmZnRplT19PRAFEVNbDidTlit1pSFgCoogDNTqlTBEds0rmY6Eo0SJgiCIDYGJDAIglgT1KzFQiVRk5OTaGhogNPpRG1tLYxGY8rvk60lUqkiCALsdjvsdjuqqqq0Mie3243x8XF0dnZCp9Np/RtOpxMWi2VJGY54gkOSJO33sSVVJDgIgiA2FiQwCIJYVWK9LeKJC0VR0NXVhd7eXuzcuRObNm1acoC6XkqkUkUURTgcDjgcDlRXV0NRFExPT8PtdmNsbAwdHR3Q6/VRgsNsNqdFcEiShHA4HCU41AyHWlJFEARBrF9IYBAEsWqo3haKogCIb5zn9/vR0NCAUCiEc889FzabbVnvuVSxkG0ZjMVQy6WcTidqamogyzKmpqbg8XgwMjKC9vZ2GI1GTXDE8xRZDBIcBEEQBEACgyCIVUCdTLRYSdTY2BiamppQUlKCw4cPQ69f/i1qo5RIpYpOp0N+fj7y8/MB8JI1j8cDj8eDoaEhTE9PAwDa2tqQn5+PvLw8mEymlN5jMcEBxHcZJ8FBEASR3ZDAIAhiRUmmkVuWZbS3t2N4eBh79+5FWVlZ2t5/o5ZIpYpOp0NBQQEKCgoAAD6fD8899xz0ej0GBgbQ0tICi8WilVPl5eWl3BOTSHCEw2GEQiHt9yQ4CIIgshsSGARBrBhq1kKW5YRZi9nZWdTX10MURdTW1sJisaR1DdlitJdpqNmjrVu3QqfTIRwOa6Z/fX19aG5uhtVqjRIcBoMhpfeIJzjUc0bNcMQKDnVKFUEQBJG5kMAgCCLtRE4WSlQSxRjD0NAQWltbsXnzZmzfvn1FdqqpRCo9GAwGFBUVoaioCAAfH6wKjp6eHjQ1NSE3N1cTHE6nc0mCQ6fTaf8dKTjiZTgip1QRBEEQmQMJDIIg0koyJVHhcBjNzc1wuVw4cOCAFrSu5JpSgQLWxY+B0WhEcXExiouLAXDBoXpwdHV1wefzwWazaU3jDocj5Z6aZASHKIrzmsbp70cQBLG2kMAgCCJtJONtMTU1hbq6OlgsFpw4cSLlxuFUoRKp1cFoNKKkpAQlJSUAgGAwqAmO9vZ2BIPBeYIjUjwkQ7KCI7aHgwQHQRDE6kICgyCIZRPpbcEYS1gS1dvbi46ODmzbtg01NTWrEvhRidTaYDKZUFpaitLSUgB8/LBaUtXa2opQKAS73a4JDrvdvizBof69FEVBKBSKchknwUEQBLG6kMAgCGJZKIoCSZIWLIkKBoNobGyE1+vFOeecA6fTuWrrW0owSQFo+jGbzTCbzSgrKwNjLEpwDA8PQ5KkeYIjlZ4c9W9GgoMgCGLtIYFBEMSSUMtTJicn0dLSgnPPPTduoDYxMYGGhgbk5+ejtrY25cbf5UIlUpmHIAiwWCywWCwoLy8HYww+nw9utxsejweDg4OQZRkOh0MTHDabbdmCQ/0XDAYRCoUAxPfhIMFBEASxPEhgEASRMpGN3IqiwO/3zwvKFEVBR0cH+vv7sWvXLlRWVq5J4EYlUpmPIAiwWq2wWq2orKwEYwxer1cTHP39/WCMadOpVMGRyvkU6Rqv0+nmCY7IDIfaMK7X6xP2EhEEQRCJIYFBEERKxHpbqMFaJD6fD/X19ZBlGcePH0dubu4arZaM9pbLWggtQRCQm5uL3NxcbNq0CYwxzM7OaoKjt7cXgiBoYsPpdCI3NzdtgiMQCGiPUQWHmuEgwUEQBLE4JDAIgkiKRN4WsQH86OgompqaUFZWhl27dqXcuJtuEgmMhYJEymBkFoIgwGazwWazYfPmzVAURRMck5OT6O7uhiiKUYLDarWmTXC0t7dDFEVs3rxZy2yQ4CAIgkgMCQyCIBZlIW8LNRiXZRmtra0YHR3Fvn37tOlBmUAiscAYSxgcksDIXERRhN1uh91uR1VVFRRFwczMDNxuN8bHx9HZ2QmdTqf1bzidTlgsliULjsjzXlEULcMhiuK8Hg4SHARBECQwCIJYBHUKTyJvC0EQIMsynn32Wej1epw4cQJms3mNVjufRNmIhcQFBYjZdQxEUYTD4YDD4UB1dTUURcH09DTcbjfGxsbQ0dEBvV6vCY68vDzk5OSkLDjUJvPIDIeiKAgGgwgEAiQ4CIIg5iCBQRBEXNSsRDgcXtDbYnR0FABQXFyMbdu2pTTpZzWgJu+Nh1ou5XQ6UVNTA1mWMTU1BY/Hg5GREbS3t8NoNM4THImIJ0YjMxzqY9RrRpblhE3jsc8jCIJYj5DAIAhiHsl4W4TDYTQ1NcHtdgMAtm/fnpGBk7qmhTIW8SCBsX7Q6XTIz89Hfn4+AF7y5PF44PF4MDQ0hLa2NphMpijBEekwn8y5oAoHVWBHCg5JkrTfx/ZwkOAgCGI9QgKDIAgNteRDzVokCn7cbjfq6+ths9lw9OhRPP300ykH8KsFGe0Rseh0OhQUFKCgoAAAIEmSJjgGBgbQ0tICi8Wi9W+oQjsVEgkOSZIQDocTCo5MywASBEEsBRIYBEEAgBb8SJIEYH4JiPqY7u5udHV1YceOHaiqqkI4HAYArUcj01hKBoNKpDYWer0ehYWFKCwsBMCzc6rLeF9fH2ZnZ2EwGCBJkjapKlXDyFQEh1pSRYKDIIhshQQGQRBR3haRQVAkgUAAjY2N8Pv9OHbsGBwOBwBEBUyZSKTAiP3ZQmTq5yFWHoPBgKKiIhQVFQEAmpqaAPBzoqenB01NTcjNzY2aUqXXp/Z1upjgAOK7jJPgIAgiGyCBQRAbmETeFrGMj4+jsbERBQUFOHjwYFQwFS+AzyQSrW8xHwyCk6l/19VEFEVYLBZUV1cDAEKhENxuN9xuNzo6OuD3+2Gz2TTB4XA40iY4wuEwQqGQ9nsSHARBZAMkMAhig7KQt4WKoig4deoUBgYGsGfPHpSXl8edpqM+NhNZigCiEikikthzwWg0oqSkBCUlJQCAYDCoCY729nYEg8F5giNVw8l4gkPNNKoZjljBoU6pIgiCWGtIYBDEBmQxbwsA8Hq9qK+vB2MMx48fR25ubtzXyvQMhkqqAkN9DgVsBLBwVstkMqG0tFQzl/T7/VoPR2trK0KhEOx2uyY47Hb7kgRH5HMiBUe8DEfklCqCIIjVhgQGQWwgkvG2AIDh4WG0tLSgoqICO3bsWDAYUgObTBUYyxFAG1lgbNTPHY9Uzx2z2Qyz2YyysjIwxqIEx/DwMCRJmic4Ui11SkZwiKI4r2mc/q4EQawGJDAIYoOQTEmUJElobW3F6dOncfbZZ6O4uDip1xYEYd2VSBFEJEs9JwRBgMVigcViQXl5ORhj8Pl8cLvd8Hg8GBwchCzLcDgcmuCw2WwrJjhiezjoXCcIYiUggUEQGwA1a7FQSdT09DTq6+thNBpx4sSJBZ2NY8mGDMZSnpOpn4lYXdJ5HgiCAKvVCqvVisrKSjDG4PV6NcHR398Pxpg2DtfpdMJms6V8HkcKDnX9amlkpMs4CQ6CIFYCEhgEsY6J9baIJy4YY+jv78epU6dQU1ODrVu3phxkiKKYscH4ckukCAJYuayWIAjIzc1Fbm4uNm3aBMYYZmdnNcHR09MDQRCiBEdubm5K61EfS4KDIIjVggQGQaxT1PIItXQpnnFeKBRCU1MTpqamcPjwYeTn5y/pvTI5gwGkvj4KqohIVvPcFgQBNpsNNpsNmzdvhqIomuCYnJxEd3c3RFGMEhxWqzVtgiMYDCIUCgGI78NB1wZBEMlAAoMg1hmRtdcLlUS5XC40NDTAbrfjxIkTMBqNS37PTO7BUFnqFCmCANZOdIqiCLvdDrvdjqqqKiiKgpmZGbjdboyPj6OzsxM6nU7r38jLy4PZbF6y4NDpdJoHB2MMwWAwKsOhNozr9fqE9xaCIAgSGASxjkimkZsxhq6uLvT09GDHjh3YvHnzsoOETM9gLLWEK5M/02pBxyCzEEURDocDDocD1dXVUBQF09PTcLvdGBsbw6lTp2AwGKIER05OTsqCI1J0RAqOQCCAhoYG7N69Gzk5OTAYDFqGgwQHQRAqJDAIYp2gZi1kWU74RR8IBFBfX49QKIRjx47Bbren5b0zuQdDhUqkiKWSyeOK1XIpp9OJmpoayLKMqakpeDwejIyMoL29HUajcZ7gSIVIwSGKIqamprRNhUAgoD1GzWyQ4CAIggQGQWQ5qreFJEkLlkSdPn0ajY2NKC4uxuHDh6HXp+/yz/QMRrz1LbRmKpEishWdTof8/Hytn0qWZXg8Hng8HgwNDaGtrQ0mkylKcJhMpqRfX70m1HKqyAyHoigkOAiCAEACgyCymmRKohRFQXt7OwYHB7F3716Ul5enfR3ZKDCSIZM/00pDgeAZMjmDsRg6nQ4FBQUoKCgAwL1uVNO/gYEBtLS0wGKxaA3jeXl5C/ZjqddE5PFIVFKlNo0HAgGIojivaZwEB0GsX0hgEESWkoy3xezsLOrr6yEIAmpra2G1WldkLZne5B17bPx+Pzo6OmA2m5Gfnz/PZ4AyGEQk6+k80Ov1KCwsRGFhIQAgHA5rgqOvrw/Nzc2wWq1RgsNgMGjPjycwYomdWKcKDlmWIctywrG4JDgIYv1AAoMgsoxIbwvGWMIv5aGhIbS0tGDTpk3YsWNHys7AqZDpPRiRGYyxsTE0NjaioKAA09PT6O/vBwAtmMrPz4fFYqFAh9gQGAwGFBUVoaioCAAfXa0Kjp6eHjQ1NSE3N1crp1I3KZbSNK7egyIFhyRJ2u9jS6rijdYmCCI7IIFBEFmEoiiQJGnBkihJktDS0oKJiQkcOHBACxxWkmwokZJlGa2trRgaGsLevXtRUFCgrVkd+zk5OYmuri7o9XowxjA2NoaSkhKYzeY1/gTEWrNRAl2j0Yji4mIUFxcD4ILD7XbD7Xajo6MDfr8fANDd3Y38/Hw4HI6U+7kSCQ5JkhAOh0lwEMQ6gAQGQWQBkd4Waj14vC/aqakp1NfXIycnB7W1tSlPi1kqmS4wFEVBS0sLRFHE8ePHYbFYEA6HAfC1x/oMTE1N4eTJkzh9+jR6enpgMpmQn5+v7eIuxzOEyD4y+dxeaYxGI0pKSlBSUgIAmJ6exksvvQRJktDe3o5gMAibzaZdGw6HQzPwS5ZUBIfqw6GWVBEEkZmQwCCIDCe2kTueuGCMoa+vD6dOncLWrVuxZcuWVd3py+QejLGxMYRCITgcDhw4cEBrQk2EKIrIy8uDTqfD3r17YTKZMDU1BZfLFVWjrgoOp9OZ1olcRGZCO+ccVVzv3r0bAO9nUkuqWltbEQqFYLfbNcFht9vTLjiA+C7jJDgIInOgb0WCyGBkWcbs7GxUiUAsoVAIjY2NmJmZwdGjR5GXl7fq68zEHgx1etbQ0BCMRiOqqqpSCnTUrIxer4+awhNZo97Z2Qm/37/sHdxMJtP+rmsBHYMzxE7UMpvNMJvNKCsrA2MsSnAMDw9DkqR5giNVIZBIcITDYYRCIQAkOAgi0yCBQRAZiNoAGQ6H8dhjj+GCCy6Iu0s+OTmJhoYGOJ1OnDhxImray2qSaSVSPp8P9fX1UBQFx48fxyuvvJK2MbWxNeqBQECrUW9tbUU4HIbD4dACKpvNRoHOOoAyGJyFRvYKggCLxQKLxYLy8nIwxuDz+eB2u+HxeDA4OAhZlpd9fcQTHGoJaWTpIwkOglg7SGAQRIYRryQqNtBVFAWdnZ3o6+vDzp07sWnTpjUNgDKpREqdElVWVoZdu3ZpmZ94YmGxYCkZcnJyUFZWpu3gqgGV2+1Gf38/GGNRpmZWq5WC1Swjk8TzWpOKJ4ggCLBarbBaraisrARjDF6vVxMc6vWhTnBzOp3zRkYn+z6RWcNkBIder6frkCBWEBIYBJFBKIqCUCgU5W0himJU8O73+1FfXw9JknDuuefCZrOt4Yo5mZDBiCyJ2rt3L8rKyrTfLSWQWMpnihdQzc7ORk2o0ul0mtjIz8/P2AlVFHxFQ8eDsxzTQUEQkJubi9zcXGzatCnq+lDH4gqCECU4cnNz0yo4QqGQdl+NbRqnvzFBpA8SGASRAUSWRMV6W0QGuqOjo2hqakJpaSl2796dMbX+a92DEVsSFWsouFZO3oIgwGazwWazYfPmzVAUBdPT03C73RgbG8OpU6dgMpmiMhwmk2lZ70mkn7UWz5mEoihpC8TjXR+Rgry7uxuiKGqCIy8vb0keNckKjtiSKhIcBLF0SGAQxBqzmLeFKIoIh8Nobm7GyMgI9u3bh9LS0rVablzWMoMRryQqlqVmI9KNGiw5nU7U1NRAlmWtIXZgYAAtLS2ai7K6g7tWfTVENBRscpaTwVgMURTnjYxWPWrGx8fR2dkJvV4fJTjMZvOyBId6X1Czx4lcxklwEERqkMAgiDUiWW8LxhgaGxthNBpRW1sLi8WyBqtdmLXowVioJCoeSxEYKy2adDpd1ISqcDgMj8cDl8uFrq4u+Hw+2Gw2bSTueptQlS1QBuMMKykwYhFFEQ6HAw6HA9XV1XEzgAaDISoDmJOTk7LLOAASHASRZkhgEMQaoM50lyQJQGJvi8HBQYTDYRQWFuKss87K2Ckoq53BWKwkKpa1KpFKFYPBgKKiIs19PRgMRk2oUv081P4NmlC1elAwyVlNgRFLvAzg1NQUPB4PRkZG0N7eDqPROE9wpMJCgiMYDC44FpfOEYI4AwkMglhl1KyFuuMfL0BUS6JcLhdycnJQUVGR0YHkavZgqCVR5eXl2LlzZ1I7+kstkVrrnWuTyYTS0lKUlpZqHgOq4BgcHISiKFHlIktpiCUWZ63Pg0xC7RHLBHQ6HfLz85Gfnw8AWsmhx+PB0NAQ2trakJOTE3WNpNrjFCk4VJNO9Z8qOILBIPx+P0pKSrQJVbGlrgSx0SCBQRCrhNrILUlS1JSoWDweD+rr62G1WnHixAm8+OKLGR/grEaJVKolUZHEioVkvvgzLTiI9BioqKjQRn66XC5tAo/qQr6c+vRYMv3cWy0y7XxYK9Yyg7EYsSWHkiTN63GyWCxaf1NeXp7mTJ4skdlmVXDMzs6ir68PDodDe4woijAYDFqGgwQHsdEggUEQq0Cst0W8LxvGGHp6etDZ2Ynt27ejuro67pjaTGSlBUaqJVGxxPtiT+bLPpOD68iRn+oEnpmZGbhcLq0+PbJcJD8/P6XdWwqGiHhkssCIRa/Xo7CwEIWFhQDO9Di53W709fWhublZG6qgCo5Uhyqox0IVFJEZjkAgoD2GBAex0SCBQRArjFoSJctywi+VYDCIhoYG+Hw+nHPOOXA6ndrvskVgrFQwvpSSqFiWIoAyoUQqFSIbYiPr091uN4aGhtDa2qrt3qr/aEJVcmRTUL3SZPOxiO1xCoVCmuDo7u6Gz+dDbm5u1BQ3vX7xMEnNSAPxMxzxBIdaSkWCg1ivkMAgiBViIW+LSCYmJtDQ0ID8/HzU1tbOC/qyIdBdiR6M5ZRExbJUo71sJrY+PXL3tqenB01NTbDZbFHBFE2oIhYjmwVGLEajEcXFxSguLgbAN3rUa6SjowN+vz/qGnE4HHEFx0J9KYkEh9o0HggEIIrivKZxEhxEtkMCgyBWgGRKohRFQUdHB/r7+7F7925UVFTE/ULJlgxGOte43JKoWLJlitRKstCEqvb2dgSDQdjtdq2cym63r/GKM4f1dB4sl/UkMGIxmUwoKSlBSUkJgPjXSKzg0Ol0URmMxYidGKgKDlmWIctywrG4JDiIbIMEBkGkGTVrsVAjd2wAnZubm/D1skVgpCsIS0dJVCzZOkVqJYmcUAUgakJVU1OTNkJ5aGgIxcXFG3pC1XoOqlNlIx2LeNeImuFQx0bb7XbtHi3Lcsr3K1VwqAIlkeBQS6rU/03km0QQmQIJDIJIE7HeFonExcjICJqbm5MOoNfCxC5V0lEilc6SqHjErm+xL+eN9uVtNpthNptRXl6uTah64YUXMD09jcHBQQiCENW/YbFYNtwxIjaWwIhFvUbKysqixkYPDQ3B5/PhySef1LKAeXl5mvhIhUSCQ5IkhMNh7fexPRwkOIhMgwQGQaSBWG+LeDd7WZbR2tqKsbExnHXWWVoafjFW02NiqSx3tz/dJVGxxFtfMuvN9OO+UqgTqgBg165dMJlMmJ2dhcvlwvj4ODo7O6HX6zWH8aUYmmUbFLxxNrLAiCRybHQoFILP50N1dTXcbjc8Hg8GBwchy7JmjJmXl7ckY8xUBIfBYND8OjLFq4TYuJDAIIhloDbrLVYSNTMzg7q6OhgMBtTW1sJsNif9Huu9RGolSqJioRKp5SGKIux2O+x2O6qrqyHLMqanp+FyuaIMzdT+DafTmbK/QCZDQfUZFEWhYxGDoijQ6XSwWq2wWq2orKzUsoCq4Ojv7wdjTBuH63Q6YbPZUj6WyQqOWJdxEhzEakMCgyCWSLLeFgMDA2hvb0d1dTW2bt26pB2sTA90l1LGtdIlUZEsdYpUph/3tUKn02m7skC0oVlvby9mZ2eXNO6TyHxIbM0n3hSpSJ+aTZs2aYZ8ap9TT08PBEGIEhxL6XNKJDjC4TBCoRAAzGsYJ8FBrAZ0xyeIJZCMt0U4HEZTUxM8Hg8OHTqkucumSjZkMFIt41JLohhjK1ISFQuJhaWRbLATa2gWCoW0QKqjowOBQCCqNt3hcGRVgEPnzhlIYMwnmSlSgiDAZrPBZrNpxpiq4JicnER3dzdEUdQEx1L7nBYTHJThIFYLEhgEkQLqdA9JkhYsiXK73aivr4fNZsOJEyeWVS6SDQIjlQB+NUqiYqESqdXFaDRGjfuMnFA1PDwMSZK02vT8/PwllYqsNpm+vtWCBMZ81BKpVIgsO6yqqoKiKJiZmYHb7Y7qc4oUHGazOS2CQ90gC4fD2mMiBYc6pYoglgMJDIJIkmRLorq7u9Hd3Y3t27ejqqpq2TfqbAh0k1njapZExUICY22JnVDl8/k0wdHf3w8AUYGU1WrNqACHzoMzkMCYTyo+GIkQRREOhwMOhwPV1dVQFAVTU1PweDwYGxvDqVOnYDAYoia5pdLLp6I2hKtECg41wyGKYtwpVQSRCiQwCCIJkvG2CAQCaGhoQCAQwDnnnAOHw5GW9xZFUdtpylQW68FY7ZKoWOKJBRpTuzYIgjCvGVbduZ2cnERXVxf0ev2yA6mVWDdBAiMeK3FMRFHUzv+amhrIsqwJjpGREbS3t8NkMkUJ86VMcktFcEROqaJzgFgMEhgEsQCR3hZqI1+8G+vp06fR2NiIoqIiHDp0KK0NrdlQIrVQD8ZalETFY6M7eWcqgiDMKxWZmpqC2+2OCqQiR+Ku9oQqOg/OQAJjPunIYCyGTqdDfn4+8vPzAfBNL4/HA4/HEzXJLVJwmEymlN8nUnCo5308wRHbw0HnBBELCQyCSICiKJAkacGSKEVRcOrUKQwMDGDPnj2oqKhI+zqyoVQn3hrXsiQqFiqRWjqrfQwid24BPqFqamoKLpcLfX19aG5uhtVqjRqJuxoTqiiA4sSbmLTRWYtjotPpUFBQoA0PiZzkNjAwgJaWFlgsFm1C1VKEuXrOxxMcoVBIcxknwUHEgwQGQcQQmSJWd+vi3Sy9Xi/q6+sBALW1tStW9pMNGYzYYHytS6JiiVfCRSVS2YFer48KpMLhsNa/0dnZCb/fD5vNFjWhKt1ZMhKaZ6AMxnxWI4OxGLGT3MLhsCY4YoW5KjoMBkNK77GY4FhoLC6dMxsPEhgEEUFsI3cicTE8PIzm5mZUVlZi586dK/rlshSPidUmco2ZUhIVyVK/3CiwzDwMBgOKi4tRXFwMgPc+qYKjtbUV4XB42e7J8aAAiUMCYz6ZaD5oMBhQVFSEoqIiAHx0tCo4urq64PP5lu1VE09wqP+CwSCGh4cRDodRUVGh9W/o9fqEpcbE+oIEBkHMkYy3hSRJaGlpwfj4OPbv368FOStJqh4Ta4GaZWltbc2IkqhYqERq/ZKTk4OysjKUlZWBMQa/3w+Xy6VNqGKMRTWMZ9qEqmyDSqTmkwkZjMUwGo1RwjwYDGqCo6OjI24mcCmCI1J0eL1ehEIhMMYQCAS0x4iiCIPBoGU4SHCsT0hgEBueZL0tpqenUVdXB5PJhBMnTixpYsdSyIYSKbUe1+12Z0RJVCyJxMJCAoK+8LLvGAiCAIvFAovFok2oUs3MXC6XZmYWO6Fqsc9Ju/ZnoGMxn2wUXSaTKcqrRr1/u91utLe3IxgMLrv0UPUHUf9FZjhIcKx/SGAQG5pkvS36+vrQ0dGBmpoabN26dVVvfpkuMNSSKEEQcOzYsYwoiYolnsBIJjtBGYzsJp578vT0NNxut+YtYDKZogTHUibvbCRIYMwnE0ukUsVkMqG0tBSlpaUAuDmmmuFobW1FKBSC3W7XrhO73b7ovV5RlKgsSGyGI5HgiPXgIMGRnZDAIDYsamPaQlmLUCiExsZGzMzM4MiRI9pkm9UkU0t1IqdEbdmyBb29vRkpLgAqkSI4oijC6XTC6XRq3gKxk3fiNcJSUH2G9RBMp5tszGAshmqOGVl66Ha74fF4MDw8DEmS5gmO2GMgy/KCk6sSCQ5FUTTBIYrivKZxEhzZAQkMYsOhlkS1t7ejoqICOTk5cW9WLpcL9fX1cDgcqK2tXfXZ+yqZmMGInRKlKAp6enrWelkLshSBQaxvYkd9Rk7eURthbTYbGGPweDwwGo0ZK6JXCxJb88mGHozlEFl6WFFRAcYYfD6fJjgGBwchy7Im3tXhCqkel0SCQ5ZlyLKMQCBAgiOLIIFBbCgiS6J6enpQXFw8zyVYURR0dXWht7cXO3bswObNm9f05pVpAiPelKjZ2dmM3u1fajYikz8TkX5iJ++odektLS3o6upCW1tb1ISqeLu26x0SGPNZ7wIjFkEQYLVaYbVatV4nr9er9XCowxXU767p6WnYbLaUzxtVcKjHNlZwRPpwRE6pSjT9kVhdSGAQG4J43hbqDkkkfr8fDQ0NCIVCOHbsGOx2+xqt+AyZUqqzkHFepo/SpRIpYimodektLS04fPgwGGNaEDU4OAhFUaKck3Nzc9d9YEMCYz4bvWxMEATk5uYiNzcXmzZt0oYrNDU1we/34+TJkxAEIepaWco0t4UEhyRJ2u9jezhIcKwNJDCIdQ9jDJIkQZIkANE3qcig+PTp02hsbERxcTEOHz68Ku7AyZAJGYzFjPMyPRhfypcLfSFxMvnvuhqon18URZhMpqgyEa/Xq43E7enp0Xo88vPzk55QlW2QwJjPeuzBWA7qcAWj0YiKigoUFxdr09wmJye1aW6RgsNisaRNcEiShHA4HCU41AyHWlJFrDyZEUERxAqhZi3UAD3yxqIG7mo/xvDwMPbs2YPy8vK1Wm5c1jo7kIxxXuQNPhODD8pgEOkmctdWnVA1MzOjTajq6OiAwWDQAqj8/Px1MaEqU6/xtWSjZzASoY6pFUURdrsddrsdVVVVUdfK+Pg4Ojs7odfrowTHUsQ5CY7MggQGsS6JLIlKNCVKFEX4fD60tbVBFEXU1tbCYrGs0YoTs1ZGewuVRMWiHttMDT7iiYVk1kkCg1DPgcXOF1EU4XA44HA4UF1dDVmWMTU1BbfbjaGhIbS1tcFsNkeNxDUYDKvxEdJKpl7ja4UaxFKQOp9EvSmx14qiKJiamoLH49HGRxuNxnmCI1UWExzqWiLLqUhwpA8SGMS6I1lvC0mS0NraiqqqKmzfvj1jbyprUSK1WElULOrxzdRmx6VmMDY6dAyWjk6nQ35+PvLz8wEAkiRp/Rs9PT1oamqKMjJzOp1ZMaGKBEY0kSV0RDSyLCd1XCLNL9Xx0argGBkZQXt7O0wmU5TgWIrRbSLBEQ6HEQqFtN+T4EgPJDCIdYWatVBvbPG+CCVJQnNzM4LBIKqrq7Fz5841WGnyrHapTjIlUbFE3rAzkaVkMNa6NI3IDNJ1Tuv1+qgJVaFQSOvfUJ2TI30FHA5HRgY2tFsfTbzyW4Kz1A2nWHGu+tV4PB4tG5iTkxMlOJZSfhhPcKgxhJrhiBUc6pQqYnFIYBDrAnWShDolKpG4mJqaQn19PcxmMxwOx6I785nAamUwUimJiiWyRCpToTG1xHJId1BhNBrnOSerGQ7VyCwygFrKmM+VgDIY0aj3Zjom81F7MJZLrF+NJEnzDDItFktUNnApvlVqf4ZKpOCIl+GInFJFzIcEBpH1JFsS1dvbi87OTmzduhU1NTV4+eWXs2KHWu3BWMkv9lRLomLJdIGRKAu00PGkLw0CWL1zWnVOLi8vn+cr0NvbC0EQovo3ljJ1Jx2QwIiGSqQSk2yJVKro9XoUFhaisLAQQLRBZm9vL2ZnZ2G1WqMEx1L6nZIRHKIozmsap+uDQwKDyGrUrEWiRm6Am2U1NjbC6/Xi6NGjcDqdADJj/GsyrPSEpqWURMUS2YORidAUKWK5rGbQEOsroCgKZmdn4XK5oqbuqNOpllqTvhRIYESjTpCiYxLNaja/xxpkhkIhTXB0dXXB5/MhNzc3SnAsZQx9soIjtodjo54bJDCIrCTW2yKRuJicnERDQwPy8vJQW1sbtYuRLQJjpRqoI0ui9u3bp5VqLAX1CzZTA3Jy8iaWSiacA5FjPtUJVdPT01ETqnJycjTBsdQSkWQggRENjaiNj/rduhaDC4xGI4qLi1FcXAyAbzKqgqOjowN+vz9qwILD4Vi24FDvE4qiIBQKRbmMb1TBQQKDyDpivS3i7R4pioLOzk709fVh165dqKysjDumNhsEhioq0rnW5ZZExSPTBcZSnpOpn2c1oWPAyaSgQKfTacHRli1bomrS1RKRdOzYxoMERjTU9B6fTGp+N5lMKCkpQUlJCQAgEAho14s6YCFWcKQqjNRrggTHGUhgEFlDMt4WAA+eGxoaIEkSzj33XNhstrivly0CI93lR+koiYpHJgfkNKaWWM/E1qSHQiGtf6OjowOBQCBtE6pIYESTqaO515rInshMIycnJ+6ABY/Hg9bWVoRCoajrxW63p0VwqP+CwSAGBwehKArKy8vXreAggUFkBck0cgPA6OgompqaUFZWhl27di14U8g2gbHc4D2dJVHxyOSxrvEEhsfjweTkJPLz85Gbmxv3fMpUwUSsHska7WUSRqNx3o6t2+2Gy+XSJlQ5HA6tpCqVCVVUEhQNHY/4LLQJmGnEDliIFBzq9RIrOFIVTpGVFjqdDrOzswCgCY7IDIfBYNAER7Ycw3iQwCAynmS8LWRZRltbG0ZGRpIOnnU6nSZYMhn1prOc4H0lSqJiWSvH8WSIFBiMMfT19eHUqVNwOBzo7e3VjJ7Uhlmz2ZzRGZnVIlu/2IhocnJyUFZWhrKyMjDG4PP5tAxHf38/AESNxLVarQn/9pTBiIYyGPHJ1uMiCAIsFgssFgsqKiqirhePx4PBwUHIsgyn06ldMzabLeXPqihK1OSpyAxHIBAAAHzjG9+AKIr4zne+sxIfdcUhgUFkLKq3hSRJC+6GzMzMoL6+Hnq9HrW1tbBYLEm9viiKmplOprOcYHelSqJiyfSAXB0M0NjYiKmpKRw5ckQ7V9SGWdU1NicnRxsIEA6HlzTikFgfZGMGYyEEQYDVaoXVakVlZSUYY5iZmYHb7cbk5CS6urq0CVXqP7PZrD2fBEY01IMRn5UaUbvaxLteIkdI9/f3gzGmiQ2n05lURlCW5ajJb7EZDsYYXC6XVvaYjZDAIDKSZL0tBgcH0dbWhqqqKmzbti2lG1q2lEgBS1vrSpdExZLJAkMQBMiyjGeeeQZmsxm1tbXQ6/UIhUIQRVHbjaqpqdEaZvv7+zEzM4Mnn3wSNptNy24spQGQIDIVQRC0CVVVVVVQFAVTU1NRgttkMmkZPioJioaOR3yyNYOxGLEjpBljmJ2d1QRHT08PBEFYNCMoy/KC3yOCIMDr9aKmpmalP9KKQQKDyDiS8bYIh8Nobm6G2+3GoUOHNIfPVFjPAmM1SqJiyeQejMnJSQQCAWzduhXbtm1bcK1qw6zf74der8fOnTvhcrngdrvR0tIS5bC8UP8GsT5YbxmMxVDLBfPy8gBw12RVcPT19UGSJDQ3N6OgoEB7XLomVGUjlMGIT7pcvDMdQRBgs9lgs9mwefNmzbNGzQh2d3drm1iRJpmLCQyAf48nW5GRiWzcuwKRcUR6W6g37Xhf6h6PB/X19bBaraitrYXJZFrS+2WTwEglO7BaJVGxZGIPhizLaG1txejoKAwGA7Zv3570c9Vzz2QyzatfVwVHov4Nglgv6PV6FBQUaJs4jz32GCoqKuD3+9HV1RXXU2AjBJYq63WnfrmslxKpVIn0rFEzgmoJYqRJpqIoyMnJgdPp1Hr+YlHHTWcrJDCIjEBRFEiStGhJVE9PD7q6urBt2zZUV1cva1cxmwRGMmtd7ZKoWDKtRMrn86Gurg6CIGDfvn1oa2tL6fnxPk9kPa7qsDwzMwOXyxXVvxEpOKh/I7uhnoP5FBYWajur6oQqt9uN1tZWhMNh2O127fxfSgNsNkElUvEh4cURRREOhwMOhwPV1dVaCWJTUxOmp6fx/PPPw2g0wul0IhwOIycnB7t27QIAeL3ehGP2k+XWW2/Frbfeit7eXgDA3r178aUvfQlXXHFFwufceeeduPHGG9Hb24vt27fjpptuwmtf+9qU35sEBrGmRHpbqF/k8W7WwWAQDQ0N8Pl8OOecc+BwOJb93qIoZsUUKWBxgbEWJVGxZJLAOH36NBoaGlBeXo5du3Zhenp6RZy8I788Ivs31FrcpqamrO/fyJS/KZEZxAqu2AlV6ohPl8uFgYEBKIoCp9OpXQMLTajKRiiQjg8dl/ioGW+dTocdO3bAbrdjamoKHo8Hd999N77//e8jPz8fR48exeDgIHw+37Ler7KyEt/+9rexfft2MMbwm9/8Bm984xtx8uRJ7N27d97jn3nmGbz1rW/Ft771Lbzuda/D7bffjquuugqvvPIK9u3bl9J7k8Ag1ozYRu5E4mJ8fByNjY0oKCjAwYMH01bvm00ZjIWC97UqiYolE3owFEVBR0cH+vv7sW/fPpSVlWlrW4rRXqrPiTU8CwaDWrCl9m84HA7k5+dT/0aWQBmMaBY6HvFGfKr16C6XS6tHj51Qlc3Hl3ow4pNMj8FGQZZlPPLII7jsssuifqaOqFW/D2688UZ87GMfw6OPPorHHnsMk5OT+OAHP4ibbroJF154IS666CK8+tWv1r7XkuH1r3991H9/4xvfwK233ornnnsursD44Q9/iMsvvxyf+cxnAABf+9rX8PDDD+PHP/4xfvKTn6T0uUlgEGtCMt4WkcHi7t27UVFRkdYvokzsGUhEPDG01iVRsaz18QwEAqivr0c4HMbx48ejalfXysnbZDJpjrEL9W+oJVXUv0FkMqk2vMdrgFVHQo+NjeHUqVPahCr131J76tYKKpGKD2UwOIFAAO9973tx33334Qc/+AHe/e53A0gswBwOB66++mpcddVVuP/++/HHP/4RwWAQ//znP3HLLbfgbW97G3bs2IELL7wQ7373u3HkyJGk1yLLMu688054vV4cP3487mOeffZZfOpTn4r62WWXXYZ77703+Q89BwkMYlVJ1ttCLflRFGVesJgusrlEKhNKomJZyxIpl8uFuro6FBQU4PDhw/OyXEtdWzo/z0L9G6Ojozh16lTG9W9Q4EQlYpEsd6JW7EhoWZa1ksKBgQG0tLTAYrFo57/T6Vzza2AxKJCODx0XPpDmrW99K55++mkYjUbk5+cDOFManswUqZKSEuzbt0/rgXC73XjiiSfwz3/+Ey6XK6l1NDY24vjx4wgEAsjNzcU999yDPXv2xH3s6OgoSkpKon5WUlKC0dHRpN4rEhIYxKqRjLcFAIyMjKC5uXnFS36ytUQqU0qiYlmLEqnIxv+dO3di06ZNCzoQp8JKC6aN0L+xXiChxUn3yF6dThc1oSocDmvXQFdXF3w+X9SEKqfTmXHXAJVIxWejl0gNDw/jTW96E1paWmC32/GHP/wB5513HgBoMdBCx0eWZfh8vnmbh3l5eXjjG9+IN77xjUmvZefOnairq8PU1BTuuusuvOMd78Djjz+eUGSkCxIYxKqgKApCodCCWQtJktDa2orTp0/jrLPOmqei0002CQxRFLXjkyklUbGsdgYjHA6jsbER09PTizb+r1WJVCos1L+hTueh/o3VhzIYZ1hpTxCDwYCioiIUFRUBOHMNuN1utLW1IRQKweFwaILDbreveXBPJVLx2cgZjPb2dlx99dUYHBxEaWkp7r777qgGaTXuWEhgeL1eAFj2FCkAMBqN2LZtGwDg8OHDePHFF/HDH/4QP/3pT+c9trS0FGNjY1E/GxsbW1K8QQKDWFHUkih1SlQicTEzM4O6ujoYjUbU1tauSi16NgkMdafeaDRmTElULKvZgzE1NYW6ujrk5uaitrYWRqNxwcevVpN3OonXv6EKDurfWF0ogOSstulg7DWgTqhyu90YHBzUJlSp18FaiO6NHEgvhKIoGV/ethI8//zzeMtb3gK3243t27fjnnvuwebNm6MeI0kSBEFY8LxRBcZKlIcrioJgMBj3d8ePH8c//vEPfOITn9B+9vDDDyfs2VgIEhjEipFMSRRjDAMDA2hvb0d1dTW2bt26ajfrBQXG+DiQmwtkQNA2NjYGl8sFh8OBo0ePZmzaeTUCcsYYBgcH0dbWhi1btmDLli1JBRRLDToyZfc6sn+jsrIyqn8jsllWzW5kQv/GeiFTzoFMYC1dzeNNqPJ6vZro7unp0Xo8Ik0vV3qtjLGMvSevJRvFyTuSv/3tb3jnO98Jv9+PI0eO4M4779TK/yJJtv/CaDQuunm2GJ/73OdwxRVXYPPmzZiZmcHtt9+Oxx57DA899BAA4O1vfzsqKirwrW99CwDw8Y9/HBdccAFuueUWXHnllfjjH/+Il156CT/72c9Sfm8SGETaSdbbIhQKobm5GR6PB4cPH9YaoFYLnU43X2DIMtDfD/FvfwOcTiiXXgrMlaysNpFTohwOB4qLizP6hr3SPRiyLKO5uRkTExM4dOhQ3Bv3QmvL9BKpVIjXvzE1NaUFWmr/hprdoP6N5ZHJ58JqspYCIxZBEJCbm4vc3NyooQnqhKqOjg4YDIaoLN9KTKiiEqn4bDQn79tuuw0f//jHIcsyLr30UvzmN79JWGmQTH/K7OwsLBbLss+t06dP4+1vfztGRkbgcDhw9tln46GHHsIll1wCAOjv74/6O9XW1uL222/HF7/4RXz+85/H9u3bce+996bsgQGQwCDSDGMMkiRBkiQAib0t3G436uvrYbPZcOLEiWWr9KWglvREzXWfmID4t79B6OgA7HaIwSCUd71r1dcWOyWqu7s748u5VjKD4fV6cfLkSej1etTW1iInJyfltQHzZ/gvdPNe6xKpVNDr9VHNspG167H9G6q7crJfXNlyDFaKjf75I1HvQZkYUMc6JsuyjKmpKbjdbgwNDaGtrQ1mszlqJG46snxUIhWfjXJcGGP4zne+g69//esAgLe97W344Q9/uOC5lazASEcp9C9/+csFf//YY4/N+9mb3/xmvPnNb172e5PAINKG2sitfiHHu7kwxtDV1YWenh5s374dVVVVa/Zlpa4vKl1ZUgI4HIDVCuTkQDn//FVfV7wpUdkQ7K5UD8bo6CiamppQWVmJHTt2LOlLK5HASPSzyN9lI4v1bwiCoO3qUv/G4mRiQL0WZJPpYKSBGcDr3lXRrWb5cnNzo6a0LcXElaZIxWcjlEjJsozPfOYz+MUvfgEA+H//7//hxhtvXPQaSUZgeL3erB/kQQKDWDZqSdT09DSeeOIJXHrppXFvuIFAAA0NDQgEAjh27BjsdvsarPYMcQUGALZvH9jmzRBmZrjYWCUWMs7Lhob0dIugdBoJRgqMSBZzJV4PpNK/oe7srkVGkch8sklgxKLX66MmVIVCIU10t7e3IxgMwm63a9eAw+FISjhslJ36VFnvJVKRBnqCIODmm2/GBz7wgaSem8yx8fl8sFgs6VjqmkECg1gWkY3c6gUTL8g8ffo0GhsbUVRUhEOHDi1ppyjdRAqMSNj+/fx/V3EtixnnrYXHRKqkc42BQAB1dXWQZTmtU7NSEUDZkDVaCrH9G6rZmcvlQl9fH5qbm7X+DUVRMv68W2myOahON+tpt95oNKKkpEQbhx45oWp4eBiSJEVNqEpUVkg9GPFZz8Ir1kDv5z//Oa6++uqkny/L8qIx0Ozs7IpMkFpN1j7KI7IWtZFbFRfqBROZEVB3oQcHB7F3716Ul5ev5ZKjUL8U1jqASsY4Lxtcx9NVIjUxMYGGhgYUFRVhz549aUmzJ8pgLMZ6FBixxJqdhUIhuFwuuN1uyLKMkydPaoFWfn5+Sv0bxPpiPYsts9kMs9mM8vLyqAlVbrcbfX19ABDVv6E24K4n0ZVO1muJ1EIGesmSTAbD6/Vm5Dj6VCCBQaRMIm8L9WYiyzIMBgO8Xi/q6+sB8MkEmXaxqHOo1ypwT6UESBRFhMPhVVxd6ix3x58xhu7ubnR3d2P37t2orKxM69rU90jlORtBYMRiNBq1/o2JiQns3LlTKyfp7+8HAE1srNYo0LVkI54DiVjPAiOSeBOqZmdn4XK5MD4+js7OTuj1euTl5SEQCGhDTYgzrMcSqVgDvT//+c8466yzUn6dZHowfD4fZTCIjcVC3hbqxChFUTA0NISWlhZs2rRpyY25q8FqmsNFslhJVCzrvQcjFAqhoaEBXq93RfpzlhIUbYRAajEEQUBOTg6Ki4uj+jfUUaBq/0ak4Fhv/RsbJahOho16LERRhN1uh91uR3V1NRRF0SZUjY+Po6OjA4ODg1EZjvV2HaTKeiuRijTQ27ZtG+655x5UVVUt6bVWc4rUWkICg0gaNWuh3jjifdGIoojW1lZ4PB4cOHBAa6jLCBQFwsmTYGedBczd/NcicE+mJCqWbNhNFwRhSdkgj8eDuro62O121NbWrohBXLwMRjKBUqYf89Um3ijQ2P6NyMk8TqdzXZZJbFQ2qsCIRRRFTUhMTEygqqoKOp1OK6dSrwP1MU6nMyP6DleT9VQilayBXrIkO0WKBAax7on1tkgkLqampiDLMoLBIE6cOJGyV8GKMjEB8YknIDQ2gjU2cgO98vJVLZFazlSkbMhgpJoNinRx37ZtG6qrq1cseElUIrVefDDWioX6N9ra2jT/jWzv38jGNa8EJDDmoygKDAYD8vPzUThnyqqWFLrdbnR0dCAQCMBms2nC2263r5vgOxHrJYORioFessiyvGiGy+v1LmtyYiZAAoNYELWRO9JgKZ6PQF9fHzo6OqDX67Fz587MEhcAhKEhCCdPcgM9vx/Cli1gcwJjNQL3VEuiYskGgZFKQC5JEpqbm+FyuVbVxT3VHgwitWMW2b/BGIPf79cER7b2b1BQfQY6FvOJN0UqdkJVIBDQRuKqE6rWg/BOhKIoWd/8Hmug96//+q/40Y9+lJYMO/VgEBsa1dtisZKoUCiExsZGzMzM4MiRI2hqasrIQJjt3w/87W9gmzYBVivYOecAWJ3AfSklUbFkw256smucnZ3FyZMnYTKZUFtbC5PJtCprW8oxzPRjnskIggCLxQKLxYLKykowxuL6b6zn/o31BgmM+SSzU5+Tk4OysjKUlZVFGV9GCu/IkbhWqzWrj7P6nZqtAmOpBnqpvD6VSBEbkoUauSOZnJxEQ0MDnE4nTpw4AYPBAJ1Ol5ECAwCUCy8EnE5gchKYq4ddSYGRTqO4bMlgLLbGkZERNDU1YfPmzdi+ffuqfwHRFKm1QxCEqEZZtX8jtm490/o36Bw4AwmM+aS6Ux9rfKkKb7fbjcnJSXR1dWkTqtR/ZrN5BT9B+lG/BzLh+k2VQCCA973vffjLX/4CQRBw00034YMf/GBa3yPZJm/KYBDrilhvi0TGQl1dXejt7cXOnTuxadMm7XGZHAizY8fm/SzZ9QptbRB6eqBccUVS77Xckqh5758FRnsL9WAoioK2tjYMDw9j//79KC4uXuXVpS4YKJBaWeL1b6hlJG1tbQiFQnA4HMjPz1/zMhI6FzgkMOazXKO9SOFdVVUFRVEwPT0Nl8uFkZERtLe3a5k+NduX6Zk+dXMy286V5RroJUuyJVI2my3t772akMAgAJzxtpAkacGSKL/fj4aGBoRCIZx77rnzLgCdTpfxhnCRJJNxER58EEJvL4TpaYinT0N5wxuAvLyEj09HSVQsazVONxUSBfB+vx91dXVgjKG2thYWi2UNVre0jESmH/OVZjUDhMi69YX6N9Qga7X6Nzb6ORAJCYz5pLvXQBRFOJ1OOJ1OALxfTR2JOzAwgJaWFlit1qgMR6ZNqFoohshUhoeHcc0116C5uRl2ux233347zj///BV5r2QmbHm93jX7rkwXmXVWEmtCsiVRY2NjaGpqQklJCQ4fPhz3ppbJGYx4JLVeux2CywV4PEBFBZAgbZnOkqglrXONiRfAj4+Po6GhASUlJdi9e/eapsxT/bKjEqm1Y6H+jdOnT6Ojo2NV+zeyKVBaSZa7W7/eUHsVV7LUU6/XR2X6wuGw1r/R1dUFv98Pm82miQ2Hw7HmpUnZNqL21KlTuPrqqzEwMLAsA71kkSRpweOjOslTBoPIapLxtpBlGe3t7RgeHsbevXtRVlaW8PWyLYORTODOysvBysqAsjKw4mIgzhSJdJdExZINwW5kGRdjDJ2dnejt7cWePXtQUVGR/AvJMuD1AitgtkclUtnJWvZvZPp1t5pQBiMa9dxYzWNiMBhQXFyslZmqE6rcbjdaW1sRDodht9u1a8Fms616r1s2jahNp4FesiSbwaAeDCIrifS2UFO88W6Ss7OzqK+vhyiKSZW3ZMNOeyRJrbeqCsp113FhoT5WUQBBAARhRUqilrTONUYt4wqFQqivr4ff749bRrcgPh/EO+6A+NJLkL78ZaCwkB/nNEAlUuuHhfo32tvbEQwG09q/QUE1hwRGNJkwLSl2QpXf79euhYGBASiKok2oys/PX5UJVWoPZ6YTaaB3+PBh3HXXXcsy0EsGtRydxtQS6xJFUSBJ0oIlUYwxDA0NobW1NaWJPxmTwZBlgDFtWlQikgrcBQGInOKhKBD//Gco5eVozcvD0PBw2kuilrTONUYQBITDYTz99NNwOp2ora1NuTZYd/PNEFpbAbcb+i98AfInPwm2e3fa1kdTpNYn8fo31CBruf0bdA6cIdu9DdKNem5kyjGJLC2sqKgAYwyzs7NahqOnpyfKhXylvGiyoUTqt7/9LT72sY+l1UAvGRhjYIwteHwkSUIgEKAxtUT2EOltoe5ExbuxqCZok5OTOHjwoOZOmgyr6YydkHAY4p13AjMzUN797rglTSopB+5TUxDvvRfhvj4MP/MMjE4njn/607Cu8E5Dpjd5M8YwMTGBmZkZ7Nq1C1VVVUv60lJe8xroWlogyDKYxQK2Y8eizxFefhni449D/uQnF8x2LLdEShgfh+mLX0TwxhvBKiuTfp1sJ5PPu3jEC7LU/o3x8XF0dHTAaDRqJSTJTOWhXXsOZTCiiTSgzUQEQYDNZoPNZsPmzZu1CVVut1vzoom8FvLy8tLiS5TJJVKMMXz3u9/F1772NQDpNdBLBjU+WkhgzM7OAgD1YBDZQWwjdyJxMTU1hbq6OlgsFpw4cSLlm40oipAkKS1rXhLhMHQ/+AEwPAxIEnTf/z7kf/u3hI3ZKQsimw1TgQDcHR2wFhWh8uKL+XEMhxcUMsslk8fUSpKExsZGuFwuWCwWVFdXL/m1WFkZUFoKZds2Li4W2QUTf/ELiE89Bbhc0Le1Qfrc54CamsRPmJnhIsTphPDss9CJIuSDB+M+VL0+GGPQP/IIDL/5DYTTp2H6j/+AdN11kF73uiV/TmL1iNe/MTU1pWU3WlpakJubq4mNTPHfyERIYEST6QIjlsgJVTU1NVHXgjqhymKxRPUyLSXwztQSKVmW8dnPfhY///nPAaTfQC/ZNQALZ728Xi8AUIkUkfkk423BGENvby86OzuxdetW1NTULOmi0+l0CAaD6Vj20jAYwKqrIfT0QJBlKHl5CcUFkJrAUKdEeUMh7Dh2DE6nE4rVCvGPfwSKiqBcdNGC77UcMrVEamZmBidPnoTZbMauXbvQ29u7vBfcuhXSj36U/OPtdmBiAsLYGBcn+fkJH5rjcsF2223QMwZl926IL73EBfEll0C6/vqEYoYxBmXHDkBRIIyPg+XnQ961K9VPRmQIOp1O680AzvRvuN3uef0beXl5NDkpAhIY0SzUv5gNxF4L4XBYG57Q3d2tTTJSsxvJiu9MLJFaDQO9ZFD7LxY6Z3w+H0wmU8aNH06V7F49sSDJelsEg0E0NjbC6/Xi6NGj2vztpZAJTt5s61YIvb1gANiePQs+VhRFhMPhRV8zckrU/ne+E9bcXCgTExDvvRdCTw8wMgLR7Ybyjnek6VNEk4kZjKGhIbS0tKC6uhrbtm3DxMTEqpfTsD17gOJisJISsKIiwOGI/8BgENt+9Svop6chMAbd008DVitEvR46UYR07bVRAkP3979Dt2XLmfeprARMJiiHDwOyDJbKVCz1NR97DAiFIF96acrPJVaOxfo31Hvn4ODgqvpvZCIkMKJZb+LTYDCgqKgIRUVFAHhsEE98q4LDbrfH3YnPtBIpj8eD66+/Hk899RSMRiN+9rOf4U1vetOarCWZ7M7s7OyqNOOvNCQw1inJeltMTEygoaEB+fn5qK2tXXYdYibstLNDhyAfOgT4/RCeeQYIhYAENdYLZjACASAnJ/GUqKIivoOu1wM6HdiBAyvzgXCmByMTvuBlWUZrayvGxsZw4MAB7ctoLUQQ27MH0re+xYVFIJD4gSYTpvbtQ8ELL/C/1cGDgM/Hp6ldeeWZ88PthuF3v4Pu6aehs9lQtGcP2AUXADodAj/4Af97T09HNf0Lo6NgBQWJS+TCYRh/+EOIL70EyDJ0L72E0Kc+BeTkpO9ArBBrfa6tNvH6N3p7ezEyMoLx8XF0dnbCYDCk1L+xnsiE+08mkWmBdLoxmUwoLS1FaWkpGGMIBAKa+eXg4GDUhKq8vDzk5uZCEISMKpFaTQO9ZEhmgpQqMLIdEhjrEEVREAqFFsxaKIqCjo4O9Pf3Y/fu3aioqEjLF0fGTJHq6oLub38DxseB1lbIb3gDsHkzAEBoaABmZsBOnEgsiKamIPzf/6HLbke3wYB9+/fHnRLFduzggaLfz4PMFUK9Wa/1F7zP50NdXR0EQUBtbS3MkYH2WkxdEkWgpIT//0UCdm9NDUJ+P/QOB5SdO8F27oQUDEKJ+LsKXi90L74IsasLcDhQIMtnPpOaHXE4IAwOwnDbbQhfdRVMX/salKNHEXrXuxI6vIsNDRC7u/lks5yc5EbvhsMQJifBVnA6GbEwgiAgJycHOTk5OHjwYNya9Y3Uv7HW959MYyNN1RIEAWazGRUVFZr49nq9UROqBEFAXl6eFkSv9fkSaaBXUlKCu+++e0UN9JIhlRG12X6tkcBYR6glUeqUqETiQi33kWUZx48fT2sjUSZkMABA8PmAkREInZ38Juf3gykKxLvvhnD//RCmp6F0dEB3/Pj89XZ1QXrkEZx++WWITifOu/RSmBIEeezgQb4bvtKfJ6LheK04ffo0GhoaUF5ejl27ds37Ys30SVcze/di6qqrYJozqGKMQVEnqs09hlVWghUVgc3Ogun1GKmtRXHM6+jvvx/6O++E0NMDw69/DZaTA8Hlgml0FMGbbwYACKdPQ/fww5De+lbAYIB0+eUwzDXuyXMZEWFyEsLYGJR4ZXxuN4y/+hXE555D8BvfANu6lYupNSCT/6arTbL9G6rgWAuTs5VkrQPGTGO9lUilgiAIyM3NRW5uLjZt2gRFUTAzMwO3242hoSEEg0E888wzUSNxc1Yxa/vCCy/gzW9+86oa6CVDMgLD6/Uu6jmWDZDAWCckWxI1OjqKpqYmlJWVYdeuXWnfbcuUDAbbuROw23mNvjruVJYh3n8/0NoKQZIg/u1vEA8dmicwxkwmTA4MoEwUUVFTA7bGOx7AmQzGWjTPRWa79u7di/Ly8riPy3TfiMj1CZ2d/IdzWa1Iwu98J2A0gg0Nwev1zvtMLD8fgscD0e3mmQiDAdDpEL7mGgCA7sknYfjVryBMTkJXX4/QRz4C+bLLIB89CogixPZ25LzpTYDJBEGWEfq3f4N83nmAyQS43YDTCdO3vgXx5EkILhdy/v3fEfz3f4dy7NiKHh8iMYmCyMj+DQDw+/1wuVxahgMAnE6nVlJlsViyOiAlgRHNei+RSgVRFOFwOOBwOBAMBiEIAgoLCzXB0dbWBrPZHCU4Vmo0bKyB3p133pnSuP2VJNkSqWyfIAWQwMh6kvW2iKybX0lTuEzJYMBggHLVVWDFxRDGx3kgqNdDOXoU4sAAmCyDVVVBLCyEMhcIqFOihoaGcGTPHuTr9YCigK1ELeTMDA8ok6zfjhQYq0kwGER9fT2CweCi2a5MbESPhSkKhH/8A7qf/QwAIL/nPZDOPz+qZEmZE5Tytm2QHn98nsBQtm8Hs9shHzwIsbcX8gUXQJiY0EqZhN5eCIODEEdGAKMRwuwslM2bgYICGH7yE+gffBC6V17hr5ubC+Ott0KqqwPbtg36O+6AdPXVCL/xjTA1NPB+EaMRyubN0N9zD6TXv36eeaT+t7+F/oknEPz858EWGtFLLIlURHNsCYm6oxvZv6FmN7Kxf4MERjQbqUQqFRRFgclkisr2SZIEj8cDl8uFnp4eNDU1RZUXOhyOtExNijTQu+SSS3DbbbdlVD9DshmMTFrzUiGBkcUwxiBJkuY7kUhczMzMoL6+Hnq9fl7dfLrJiAyGxwNMT/MsBgAWURfPzjsPitcLiCLYkSOaIFLLxhAO47xAAKYrr4SSaCJRJLLMS1eS/dJlDJichHjffUBhIZQLLwSSMNNZixIpl8uF+vp65Ofn49ChQ4ve/DO9REoQBMDng+4Xv4DQ3Q0AMPzyl5COHgXi3MwTBVKsqAjBr38drLQUwtAQBEmCMneuAYB84YXQ33cfFIsFzGyOKoGSX/Uq6P/v/6BYrRACAbC8PAjd3TCMjkIYGQFEEcLUFOQDB8A2b4ayaxfEZ5+F9eKLoVRUQDx5EtIb3gDlwAEIk5Mwff7zENvaIPT2wvLQQwi///0Ife5z2kQsYXwcxltuQfCzn11whC+xMEsJqiP9N6qqquL2b1itVi0IS1eAtZKQwIiGMhjxiXdc9Ho9CgsLtUyCWl7ocrm08kK73a5lNxwOR0rHdq0N9JIllR6MbCez72ZEQtSshbpjHO9CZIxhYGAA7e3tqK6uxtatW1f8ZrhiGQyfj5vZLRb0d3VB98ADgNcL5fLLwc4+O2rHl+3fD7Z//5n1nj6t1YpWiSJ2DA5CnJgAc7nAjhxZeMytJEH885/Bdu4EO+ssiPffz3e/t25N/JzJSYh33gmhqwsoKIA4NQXlhhsW/fiqeFyNDEGkJ8rOnTuxadOmpIKKbCiRUsxmKJddBt34OBgA6fLLwcxmxPt0CUWdIHCvlf5+GH/2M4hdXQh94hO8BMpkAisqQvhjH4NSVQVhYiLqqay4GMxmA9u7F7q2NoTe8Q4Y7r4bwunTEEIhsLkvHun1r4dy+DBybrgB4uwsL7caH+dN6I89BmX7dojDw2AOB8SeHj5BizEYfvYzQJIg79sHXXMzdCdPQpichPkd70D4mmsgvfOd/CNMTkJ/++0Iv//9PJNGJCRdQXU8z4HYACvT+zcy0d9gLdnIPRgLkUwQHa+8UO1nGh4ehiRJUROqbDZbwmMda6D36U9/Gl/60pcy8m9DGQwiY4ksiVpoSlQ4HEZTUxM8Hg8OHTqEghWccBTJimQwJiag+8UvgJkZyB/+MFBWljBjoLv/fqCzE4LXC1Gng1xVBRQUAIxBvOMO7pExMADlyiuhGAwYHBxEIBDAgQMHUOrxQLz9dh5w6fVgCzVZnT4N8aGHIAwNAX19EH/9a6CwkAd9u3eDXXhh/OeJIoTGRgj9/bxB/NChpA/DapSfhcNhNDY2Ynp6OmVPlGwQGABvzJdzcs4Y6C1Cos9k/PGPoXv5ZQguF4zf+x6Cn/88lCNHAJOJ91QAYDE9Hqy4GMEbb4TxJz+B4vNB//zzUHbsgOB0Au3t3G9DUWC66SYEv/UtyCdOQGxvhyDLYEYjhOFhCLIMXXs7IElgRiP/ud8PMAYhGITxJz8BMxh4eaDXC3i9EP1+CC4XmNMJ3QsvQNfaCsHthv6vf0XwppugnH024HZD7O+HEiHAiZXDYDCguLgYxXNDB9T+DbfbjYGBATDGNLGRKf0blMGIhkqk4rOUzI7ZbIbZbEZ5eTkYY/D5fNr10NfXBwBR/Rvq9RAIBPD+978f995775oa6CULjaklMpJkG7ndbjfq6+ths9lw4sSJVa3zTcUZOylkGbof/Yib2QWD0P34x5A//WkuGuKgXHIJxK4uMIeDB3cFBcDQEMQ//QliXR33MLBaEervR4/Ph9DevTDZ7SgbHITwwgsQ3G6w3FwIr7wCXHll9Iv7/fz5JSX8defG0wo2G1BcDJw6xQPBRM24jEG86y7uy5GTA4yNgaVQErHSAfz09DTq6upgsVhQW1ub8nmT6T0Y6vFTs1jqFCkkWPO8DMbMDBe2c6nr8A03QGxsBKxWXgp1+PCZJ8/MwPSNbyD04Q+DlZRwB3CLBXA6IY6OQmxvh9jTAyUchnTDDZD37IE4NAT9Qw9B7OuDMDwM02c/CwgChMlJrRSPWa1AKMSnpDHGsx45ObzUanqan1uMQQiHNbNJgTGebWtpgfnd7+brUBQgGISoKNDffTeUp5+G/i9/gSBJCH3605Bf/WrAbIbR5eKvm2D87kZgtURzbP/G7OwsXC5X3P6NvLw8mNYg80QCIxoqkYrPco+LIAiwWq2wWq3YtGmT1s8UeT3o9Xro9Xp84QtfwIsvvrjmBnrJIsvyoteuz+dDxRLMXDMNEhhZgpq1UA1s4t3kGWPo7u5Gd3c3tm/fjqqqqlX/MlBnX6fti0inA6uthTAwADDGd3gTZWMkiQeBs7PA9u1gqhOzw8H7JGZmALcboakpuB98EAXbtqHSbkeLyQR25ZVasAadDigrg/jUU2BuN9iRI8D4OMQ77gAUBcqVVwJVVWAlJTxQYww4eRICYxB8PghPPsnXqfozqAgC2OHDEEZGeKnM4cNARO3+YqxkBmNwcBCtra3YsmULtmzZsqS/XaZ4dSRiKQJN/RzC+DhMH/84YDYjeNNNYIWFYIWFkGtruYu4zaZl1XRPPw3jD38IYXwcOa2tXLCOj4PpdJDe+15Ir3sdYDZDqaoCcnLAHA6Ybr4ZYkcHFxReLy8JlGUwux1CKMR/rhoJKgoXHILAz+twGLDZuPhgDEySIPr9/Dw2GM4YEM4Jf2F6OuozGn/wgzMiSxRh/OIXEf7sZyH29mL/Aw8gp6wMyi23gG3atLQDvw5Y7fNZEATYbDbYbLao/g01uxHZv5GXlwen07kq/RuZem2vFVQiFZ90l9JF9jNVV1dDURScOnUK//qv/4qOjg6YzWZ8+ctfxp49ezA2Noa8vLyMHaBAJVJExpCst0UgEEBjYyP8fj/OOeccOJJpUF4BVmKcKquq4sHNyMiCI2OFjg6If/sbhGAQbGKCe2AcPQrh1CnAbIZ85Ah8jz2G0yUlqPB6YVIUBAcGIJaUAE4nD9LOPx/CyZOAJEGYmYGSlwcEAhBvvRVCWxsEWQampqB88INg550HJgh8x3j7dgiPPAI2PAwUFibsFWHFxWD79vHAMsWAbSUEhizLaGlpwenTp3Hw4MFljfKL3PHPxC/dJQuMqSmYPv5xiIODgCjC9JGPIPCrX4GVlSF0443znqOUlvLzZ2SEC2O9HoLLxUXCLbdA7O5G6EMfAtu8GUJnJwx33gmxsxPi6CgP9CWJP7a7m58veXkQpqa0jAUCgTMlgooCIRCAYrdDMBgguN0QVAEiyxDCYf7YufM0LpHnlKJA19kJ4etfhzg5CV04DKGrC+x974P/9tu1RnHDL38Jed++DTE6NxPK/iL7N7Zu3RrVv9HR0YFAIAC73a49ZqX6NzL12l4rqEQqPivt5N3Z2YlrrrlGM9D705/+hE2bNmnlVM3NzdqEqtUU4MmQTGzk9XphS2L4S6aTGUeciEuyJVHj4+NobGxEYWEhDh48uKYXknrhJKPSk2ZoiLsaKwrEhx6CXFMDVFbOexjbtYtPA7JY+JjaucZrtLUhZLGgcdcuKLt2YdfFF8P4xz+CBQJgkgRZFCHedx+Ut74VMJt5H4Yo8iAtP58HZ2VlwMsvc0EhCEBR0Zk3FgSwigqe0Sgr41OhEhkKbdoEZYk7wekukfJ6vairq4NOp8OJEyeWbYKUCWaACxHv+CWzVsVmg7J3L8ThYUAUoZxzDrDAJDa2dSuYwQB5/35upuf3Q/B4eIBvs0F63eug7N7NH7xrF6DTwdjbC+ZyARYLf+xcTwWmpqDs3Qvphhug6+yE/p571IXzf4oCzAkLKArPZkR/QJ7VcDo1kZLEgeK9RYoC3VwpFauvh/X88yEdOgRxbAyCzwe9Xg/pda9D+NOfPvNesjxvjO56INOC6oX6NwYHB6EoihZc5efnp61/gwLqaKhEKj4reVwWMtCLnFCljsRVBbjNZtOuB7vdvmbDCiiDQaw5sixjaGgIsiyjrKws7peDmiYcGBjAnj17MqJmbyX8GgSfD0JfHy8tstvPBDCTk/x/1ZIpQYCyfz+E7duB6WkIwSDQ2opgXR1GTCbkFxZi07XX8kzAm97ERcA998D+7LPcOM3j4aNBL72Uv2YgwMUKeLOucOgQr3c/cmT+IktLoVx7Lfe1kKQz/3JyeNDV1wfU1CQ/zjYO6cxgqIaLFRUV2LlzZ1q+DNbSDDBZIgXFxMQEGhoaoNfrUVBQgPz8/Hk7Xep1Jx89CnFoiE9oOnAg7muLzz8P09e+Bv8ddyD4wx+CFRRAfPFFGH/5Sy1LwBwOsMgSP58PuieegK6tDUplJcKvfS2MP/nJmalWgoDwVVdB19sL3cMPa+Nno7IO4TDPrC0kHuamTCWFovAsSARqs7ihv5//YG4d4qlTUCwWKK99LXRPPAHD738P/333Je3vkg1kqmCOJFH/xsTEBLq6utLWv0EZjGioRCo+K/Ud8OCDD+Id73jHogZ6RqMxSoAHAgFtQlVzczMkSYqa2Jabm7tqQjHZMbWUwSDSTqS3hcfjQTgcjuuc7PV6UV9fD8YYamtrM0btCoKQ9kZv5eyzIfzjH3wX1ucDSkv5ONo//QkAIL/lLdpoWHbZZVDDAUVRMHnvvfCZTCisrob1qqt4ZgLQMhBs1y7oH30UGBjghnyBAASvF8qhQ1HjZlltLeTaWu6xMTXFA7zYG9Lp0xCfegrK618P8dFHgZERKG94Ay+t6u4GO+ssPt60rQ3sxAleH58C6RAYqigdHBxMu+FitmQwYnuV9Ho93G63ttPlcDiixokyxiBfcQXkK65I+NqGH/4Qhr/8BfB4YL76aoS+8AXIF1wApbYWwcpK6F55BQiHIb35zVHPM33+89DfcQcQCkHs64PxN7/hTuGjo7yp22aD6eabeZYiHOY/KygAvF4IMzNnXmiR80Lr30gXaj/HzAzM//EfYP/5n9wXRJZhOXIEoY99DNJ738sf09sL/V//ivCHPrQsgb2WZFMQuZL9GyQwoqEMRnxWokRqOQZ6OTk5KCsrQ1lZmTahShUc/f392sQ29Z/Val2x8zzZKVKWhaZYZgkkMDKIWG8LvV6PQJzAYHh4GC0tLWndfU4nae8VqKyEcs01EJ99FmxwEMLDD0N89lk+WQqA7k9/gvzJT0aVJanGeZZdu7DzhhtgHh8HCwbnlbYIpaUIORyQN22CrquL18z7/RD27kVUmGyzAYOD0P34x8CpU1De8x6wCy7QTPKEp5/m42dPn4buox/lPRgmE3Q/+hEXRpOTfJrV3M4ha26GctVVQApZp+WWSAUCAdTX1yMcDuP48eNpF6XZIDAkScLJkycxMzODY8eOwWw2Q5bleaUmLpcL/f39kGUZHR0dKCkpQV5eXkKTSuXAAeBPf+JTyEpKoOzaxSc31dfDfN11vLSqtBS6J55A8Nvf5gZ43/0upH/5F+jnhDIMBihVVdA1N/P/Zoz3ZahfRozxhvGxscQleGsBYxACAQh9fby8SlFguvlmGH/6U8BgALPZILhc0N1/P4L/8z9Z5zaeqedzsiTq34gU1cn2b5DAiIZKxuKTTuEVa6B3/fXX47/+67+WbKAXOaGqsrIyKuM3OTmJrq4u6PX6KMGRTnPixcQXY4x6MIj0kcjbQqfTRQXqkiShtbUVp0+fxtlnn60FRZlG2r0w9HoevPT2Qhgdhfjoo2DbtgHj4wDAvSQiAq6xsTE0NjaivLwcu/71X3nN+COPQKivh3LNNbxPYg6hvBwDF12E7QB0IyO8/KqtDewtb+F18JLERYQkQXfTTRCeew7C9DSE730PsskEdsklPPArLYXw0ks8u1FdzceFhsPcTXyuaReM8QzJiy/y3o6jR/lnO316weZ1leUIt8nJSdTX16OwsBBHjhxZkfR1pgsMSZLQ19cHh8OB48ePw2g0IhzTsxBbavLEE0/AYrFgZGQE7e3tMJvNWiAWufOr1NRwA709e3hPTkkJdM88A+MXvsB7KhQFuqkpwOmE/o47YPrylyEEg9A98wyQmwtlbuKY9KpXQRwdhXD69JmSJrWPwmjkE6BEkZ+bopg4c7HQ71YKtS8EgDA6yrMwEc3l4qlTYF/+MlhpKWCxQLroIpi+8hXeMJ/hE6rWU1Adr39DbRhfrH+DBEY0mVwOulao8Uw6jstqGOjFZvwURcH09DRcLpd23zeZTFHXxHImVMmyvGjG0OfzZUxVynIggbHGLNTIrdPpIEkSAO5RUF9fD6PRmJaG3JUk7V4YAJTXvAa6+nqwwkLuO/CqV50pc5rbEVUUBe3t7RgaGjpT/hMIQLzrLu6cDUD885+hvO99mnuxGAqh4sknIeTlQRgeBuYCO/GOO3jdekUFzzQUF4OddRaEp57igZvVyoWNLEN45RUI9fXaz4SHHwYKCnhJ1K5dvKwlNxdwuyH87ndATg7v+Xj4YcBmg/DSS1Be/Wqwa6/lTeoLHNdUBUZkOdCuXbtQWVm5YgGC+rqZ6IUxMjICl8uFvLw8HD58OGlncp1Oh7KyMtjtdkiSpAVinZ2d8Pv92s5vQUEBlD/+EYLdDni9AAD53HMBsxnMYoEQDEKuqYF08cUw/OEP3BgvFII4NITAN77By4kYAwQBhiee4FOnVPEjCFyIqsdV/V+dLrGIyJS/QaTYZAwGtUldp4Pxv/8bzGqF+ZprIJ17LqR3vYtnQ7xezagwE8hUwZwuYg3O4u3mquVUsiyTwIhAUZQl76SvV9T7/3IzGGtloCeKIpxOp2YyK8syPB7PvBLDyAlVqZwDyZSPUQaDWDaLeVuomYC+vj6cOnUKNTU12Lp1a8bf4GMzL2khNxfs1a8Gy8/nu7k7d/LswBy+mRm4Pv95hI4dw4njx2FWG2lzcsB27eJTcQSBB/wRDY6ixQIxFOLZEL+fl0cB0P35z1A2bYLQ2Qlhdhbye98LZf9+iHv3QhFFngVxOPhY3Acf5GvavRsYHuame2YzMDMDds45Z3o1GINsMEB88kk+XWh4GEJHBzA5Cd3MDG+Wve66hIcg1RKpUCiExsZGzM7OrtroYlEUMyogixSdeXl5KCgoSPn6UT+PXq9HUVERiuaEbWQ51cDAAABoO1z5ej3MZjOkSy+FuHUrhI4OhN/3Pijnnw/l8GGY/+Vf+PlosUC6+mr+RnPrCvz4x7C85jVnFqDXQ66u5u7dkcxtPmQlEWN0hdlZGHt7Ybj7brC8PMBqRfhtb0P4/e/nIisDdvIy/Z6bLhbq3xgcHMTMzAwCgQBmZmbiDkXYaFCJ1HzSITCmpqbw1re+FU899dSaG+jpdDoUFBSgYC6miCwx7Orqgt/v1yZU5eXlweFwJMzeqNmdha6ZUCiEUCiE3DlD12xm494Z1hDV20KSpKiSqHiPm52dRU9PDw4fPqw1nWY6K2IIZ7NBed3r4v7Kfe+9CP/853BYrdj8zDO8Ify1r4Vy8cW8FKmqCuz4cf7guXF2mJnhmYTGRthGRiAYjWDl5RACATCjkTfRBgJnTAPHxsAOHIB0yy28ZCoY5BmOnh5gbIxPrLJYwKqq+LSrcBg4fDi6EVwQgJ07wWZmuDHb2Bh0IyMQJifBJAksXj9GIKCVf6VyXKempnDy5EnYbDbU1tau2i7bSruNp0IwGERdXZ3Wc9Ld3T1vbYsFjgv9PracamZmBpOTkxgdHcWpU6eQk5OD/MsuQ3lnJ0ofegi6T34S/jvugLJ5M0LvfCeUqiron3wyqi9I/Oc/AZMJrKCA91owBma3Q5wrB4xC/SxrUQ6VLuaEBsAb0YU5t3TTV78KZfNm5Nx4I8LXX4/QZz4zf6jCKpEp5/NaENu/8eKLL8LpdEJRlHn9G3l5ebDb7Rsq4KYpUvNZrsAYGRnBNddcg6amJthsNtx+++244IIL0rnEZRFbYhgMBrUR0a2trQiFQlETqiJ7miIrVRLhncuAk8AgUiZZbwuXy4W2tjZtSlSmulLGI+09GCqhEIT+ft5/AX4jG/rtbyE99RSqZmdhGhriRnfFxUBdHURFgXLttWA7doDt2MFfQ5IgtLRAeP55KIcPQ/j736EPBKCUloKVlYEdOwaIIoS2Ni4iXC5AFCH++c9ge/ZAUUs3XC4+dtbp5I2subnc/2DHDihzO8txm1kdDrCLL+b/PxCA0tgIYe9e7tocWYeuKHz61DPP8JG6+flJCQzGGAYGBtDe3o6tW7eipqZmVb8AM0VguN1u1NXVIT8/H4cPH4Zer1+y0V4yz4l0mq2pqdGmwE11dqL4Pe/hPTkAcq66Cqcfegi2a65Bzn/+J3QvvQTLa14D/3/9F/TPPAPTN78JAJCOHoV+rt9C2bcP4auvRs4nP6kF41Fkq7iIh9rHEQjA/La3AYIA47e+Bd2ddyL0/e+fKZ1yu6F/+mnuik6sKg6HY8H+DafTqYmSdPlvZCo0RWo+ahndUo7LqVOncPXVV2sGen/+859x9tlnr8Aq04fJZIqaUKVeE5GeNE6nE3l5eZpoWKg/RRUY1INBpITqyL1Y1qKrqws9PT2orKzE6OhoVokLYIUyGGNjEP/yFwjt7VDe/GZ4d+xAfXs7CoeGsE0UYQwGeQZAEHifhskE5cQJ/tzZWd5bsWULhBde4P9GR3nzd0MDRMagWK1gb3kLWHU1Fxj33MMbsp97DuIzz/AgbnYWQigE8bnnIIyPQ/7AB7jYmUvdKkeOAJs28elSirK44VhODpT3vx9CXx/Y1q1R7t/C44/z3o6xMYi/+x3YJZcsGuxKkoTm5mZMTk7i0KFDWkp3NREEYU17MCIF1vbt21FVVRV1nS3FaC8lUeLxQPfPfwJXX43CwkI+o33fPu4ODyDkdOIVjwc7f/tbbHn+eSAchnjqFMzvfS+fGOX3AwD0L74I79//zpvGw2GIra1Qqqog9vauL0GxGHOCQ3fqFHLe/W5Il1wC+eyzYbjvPgiTkxDb2xF+xzv4Nb9iS6DGZpXYYxGvf8Ptdsft38jPz1+y/0amQiVS81mq6HrhhRfwlre8BS6XC1u3bsU999yD6urq9C9wBREEARaLBRaLJcqTRhUc3d3dAICWlpaoCVWR15TX64XZbF4XwwNIYKwCkd4W6g0p3heWOkY0FArh2LFjAPhI2mxjyRkMxqD78pfBjh2D8trXAv39fMe2pgbi//0fH007Ogr/L3+JpsOH4Tj/fGx705ug/9OfeAaipgasqorv/s/MALm5QH8/dHfeyR2R3/AGsB07eLDX0wOxsxOspgZhpxNyfj7v75iagvj440B3N4TeXp6p8HoBu51nMh57DMJLL0GYmYFuZATSl74E9qY38UBIFM/M+Y+9OYyP88BwbloQAGBggPtleDwQJiagHDvGMyIA2J49EF55hZdImc1gW7ZAbG9PGLzPzs6irq4OBoMBtbW1azYEYC17MGRZ1gTWkSNHkJeXF/X7lcxgAID4yivI+eQnIba1IVRXh9BHPwoUFkJ+zWu4SZ+iQHzta3HeBRdgtqoK7IEHgLl7QtvrX4/NDz+M3Lk+C/nss/k9YnKSj709eBDh974Xxq99jXtazDWEw2CIKjNazwhjYzD87ncwmM1gOTkQgkHo//AHyEePQj7//DOPGxoCczj49U+klYXEVmT/xubNm6EoCqampuByuTA0NITW1latOXa99G9QidR8liIwkjXQyzZir4mpqSnU1dXBarVibGwMp06dgtFoxEMPPYSKigpcfvnlmJ2dTYsPx7e+9S3cfffdaGtrg9lsRm1tLW666SbsjOhdjeXXv/413vWud0X9zGQyxbVLSIbsvrqzAEVRIEnSoiVRp0+fRmNjI4qLi7WSDq/XuzKlRivMkjIYg4PQ3XILhKEh/u+BB/iUKFmGcsUVUC69FMKTTyLU3Q1XTg42v/GNKC0r42NhT5/m4uHAAR6gDw1p5Um6224DOjoguFwQBQHydddB6OqC0N7OJ/UoCixOJ3yf/zxy8vO5kV4wyEeLDgzwuf4DA5De8x5g716e8XjmGd5gazJByM8HW+RmKrS3Q/jnPwFF4Y3qu3drrysMDvL1zvVnqAIDVivgdHJTNbMZMJkSHteRkRE0NTVh8+bN2L59+5ruqK1ViZTP58PJkyeh0+lw/PjxuAJrwbXNzsYNSBe9yTMG0yc/Cen1r4fxm9+E2NwMhMMw3norACD0la8g9LnPIfTZz3IBOheg2SoqoFx8McSeHsDrRZkgwDQ+junNm2EeGYHS2Qnhne+E3mZD+EtfgunWW6H/xz/OjDw2GqEUFPDpUpOT3IByo+D3854nRYHY3w9FLX9UFIjt7ch597uhbN2K4M03g8UxKV0KFERyUsnmiKKo7dICSOi/oQqObOzfoBKp+SRjJBfJ7373O3z0ox9dkoFetsEYg16vR01NDWpqarQhCvfffz9+8Ytf4N///d9RWFiIQCCAu+++GxdeeOGSe28ff/xxfPjDH8bRo0chSRI+//nP49JLL9WmYCXCbrejPWKgyHLufSQwVohIbwv1phzvDxU55WbPnj1Rrt3qNKZsS9EvKYNRUsID9qkp/nn1esDt5kGDXg//vn0It7ZCbzKhTFGA5mawkRHov/lNCJ2dgM8H1t7O+y8GB8EuvBAwGCBfcgl0fX1gXi830cvPB6ushJCTwzMdU1PQWSwQGxqAykoe4Hd2gnm90LW3c/Gg10P3z39C2bIFrLYW7MEHwcrLwXbv5iVVkSgKd+3esoUHlOEwhMce42ucc/9mW7bw6VZnnQX20ksQqqoAi4X7Z6jk5kJ5z3uiXloNkIWXXgJmZyGff7527px99tkoicyOrBFrUSI1Pj6OhoYGlJWVYdeuXQm/8OMKDFmG/q9/Rc4tt8D/m9/wPpiIa23ec1wuGH/zG4T+7d8g9vQg5z3vgTA4CP2dd0K6+GLoGhr483U6hD7xCfVF5pfLGY0I3H47/79f+xoc994LQZZhHxrifhduN5jLhUBeHoQPfpCbRKrXFGNgTicXnaOjPMu13onw0wBwpkwsFIL18GHI27Yh9PWvw/SZz0AYG4PO44H5LW+B78knl+0enm3335VkOcdiIf+NoaGhqP6NlXZTThdUIjWfZEUXYwy33HILvvrVrwJYvoFeNhArvtQhCt/+9rcBABMTE/jud7+LP/zhD/jSl76EtrY2HDx4EBdddBEuvvhivOpVr0pafD344INR//3rX/8axcXFePnll3F+RMY3FkEQ+Ij/NEACYwWIbeROJC68Xi/q6+sBALW1tfOs4dUTMRljlkwiWR8M4e9/B4xGsFe/mu/uqw3SjIHt2gXxjjvAcnIwZbOhcWoKB00m5LpcYE4npO3bIT70EM8CTExArK+HkpfHJzoNDIB1d4M5HBC2b+cZAJ0OwssvQ3/ddWDnngsUFvLA0e+HYrFA39YGoaYGQnMzxIcf5iZhc2M0wRgfk1tYCKG3l2dHCgvBjhzh/Rrt7byJfGoKQl0ddxgfGgLbv59nIQ4e1IzT2J49fC1tbWBbtoBdeCGUvLykdqBFxmC/7z4IOh0knw99jzwCz4UXxj13tGPc1gacPg22wA0lnaxmBiOyX2nv3r1R4jzZtRm/+U3o7rsPgscD83XXIfTZz0K66qp57wMAuieegOk//xOYmYHusccQ/NSnIPT1QZidBQQB+qeeAsvL454nRuOZbNQiSNdeC/199/FrICeHj1EOhyHo9TA5nfD8x39A/5WvgE1PQ5BlKDod4HJBnJjYOP0Yic4pRQG8XugaG2G+9lqw4mJ+TY6OQt6xI664MH7/+5B37YJ8xRUrvOj1RzrF1nro36ASqfkkIzBiDfQ+9alP4T//8z/X/bFcLLtTWFiIw4cP48UXX8QLL7yA0dFRPProo/jHP/6BD3zgAxgeHsaJEyfw8MMPpxwTTk1NAcCiGZHZ2VnNcPDQoUP45je/ib1796b0XirZE7VmCYt5W6gMDQ2hpaUFmzZtwo4dO+JekNksMBbcxfb5oPve9yD09wM6HdjTTwPT02Dnngv5m98ETp+G7tvfBsJhhIeGwIaGcPDECdj8fsBs5q7eXi+UK6+EePvt3IAsJwfyDTdAvP9+LuhGRng5SU4OmMnEd5bHxiBMTEDweCBfeSXvqXjlFQh+P8+cVFRA9//+H4SxMQheL89e2Gxg+/eDFReD5edDfOABiCMjYNPTEINBML0eGBvjTeQmE4TWVv65gkFuzud0glVUQLnsMp690Okg/vWvQH09hIoKKG9+M2C3I5mQXDQYIJvN8Hd1YWJkBKazzsI5558PXYIdH/G++4D2dgizs2CtrVCuv56P2F1BVqsHIxwOo6GhAbOzszh27Bjsdvuiz4mXXZHe+Ebo/vIX/vcyGCDFjEOMvH6FwUEILheE06ehCAIEWeai0+fj4iAvD76nnooaO7vomkZHof/jH/l5Wl7Op6QVFgJmM6TaWrDycuTs3w+87W0Iz8xAfOklYGgI4sjIxhEXiTCZ+N+NMX6tBwKQ1dG/sgz9E0/Auns3wldcAYExhD77WeS8610QBwehz8mB/I9/IPid7yya4ciEqWiZwkrt2CfTv2GxWLTpVJnSv0ElUvNZzMU71kDv29/+Nj70oQ+t4grXjmTKx2ZnZ7VpU6Wlpbj++utx/fXXAwC6u7tx8uTJlM99RVHwiU98AidOnMC+ffsSPm7nzp343//9X5x99tmYmprCd7/7XdTW1qK5uRmVlZUpvSdAAiNtJOttIUkSWlpaMDExgQMHDmimXfFQMx/Z1oeh0+kQmhvLGRejkde8Dw7y2feNjWClpRDcbgi9vZA/9CGEc3PBBgYgSBJ31DQYoJxzDh/3WVMD7NnDHbP1et7cnZcHoacHQjjMPSZMJojt7ZBLS6Fcdx1vED99GkIoBGYwQFAUsNJSMIMBsk4HpbIStp/+lDfQShKYIECprQUqKyFffz2wdSvfka6oABsZ4b0aoRDvrWAM8PmgXHklBIsFKC3lnhhqM1VFheZxIbzwAoS//Y1nQvLzIQaDUN71rqSD0gm7HbMASvftQ57JBGUuMI6LzwdxToyx/PzEj0sjq5HBmJmZwcmTJ2G1WlPy+Ii7ttJSMKsV2LaNZx4WaAyXrrgCxv/6L/63NJkgX3ghgl/4Akzf+x4gy5Bf9aqUxIXuwQdh+spXuAA0m3mwbLMBjCFw881RO+yhz32O9xc88gjE6Wn+t4ww2mOCwPt6IkQHM5u5Y/g6RbHbIQSDEKan+Q8kCbpXXuHlaJLEyxVPn4bx178GBAG6xx4DAN57ZTLxLGWSrPed1WRZrXKxeP0bHo8HLpcLnZ2d8Pv9GdG/QSVS81nIqXpqagrXX389nnzySRiNRvz0pz/FNddcs8orXDuSERg+ny9hGdSWLVuwZcuWlN/3wx/+MJqamvDUU08t+Ljjx4/juOoZBl5Zs3v3bvz0pz/F1772tZTflwRGGkjW22Jqagr19fVaR/9ik34EQVg5T4kVZFEnb70e7OhR3jehKBDcbmB6GpAkKMeOYdTjwZQso2L/fjiHhsCqq8H27eONz3l5PBgDuP/E7t0QmpuB6mqIJ0/yyU8tLRAAHsB3dID190N+5zuh++tfgZYWKDt2cEfvoSEIdjv0IyMImc28T8Jk0t5Pfvvbofv736G7914oV1wBdtZZkK+4AkJZGYSnnwYMBh6sOJ0QOjogSBLYWWdB0euh+7//458ppkyGnX02X7coAj4fb2RPIkAOhUIYHR1FqKgItW99K2zPPANhfBzir38N9prX8M8TA9uzB0pvL/+PqirNsG8lWekejOHhYTQ3Ny/J1T6ewGAlJfA+8ghEvT5hRkB7js2G4I03QtmxgzdnCwLka66B75JLuLBI0Vlb7Oriotrl4sKGMZ5Js1qjPVHmUHbuBNu8GWxyErDb+YCAubUJgsAHAkQY8q1ncQEgrvmgatSnXVOiyDclGIM4Pg6ptpb/3O/noltR5k98i4EyGGdYq34Ug8GAoqIibUMuEAho5maNjY1r1r9BGYz5JDommW6gtxoslt0BeOl8OpvcP/KRj+CBBx7AE088kXIWwmAw4ODBg+js7FzSe5PAWCaKoiAUCi3qbdHX14dTp05h69at2LJlS9I3v2wUGMlMkVIuuwy48ELexH333bw0RFHQ6fOh9+RJHLjsMuS+732QOzqAwkIuLNRpMbOzEB59FOLjj0Po6ICyZw9vkjYYgJ4enoUIhyFYrVCKioC2NrArr4R0xRUQBgf5TrUgQPzLX4CeHlgHByG++CKY3897JioroVx9NXT//CeEujqw2VmIk5NQPvIRsO3bgYkJCH4/WEEB3zkuKAAGBiA8+SSE8XGgsxMoL4d4221gF14IdtZZfN1zo2zZxRfzhu5QCKyyclG/DI/Hg7q6Ouh0OhSWlMCalwfMzEDo7uavJwh85O2TT0J5y1u012O7doGVlXFhsUpB0kplMCKHISyW+VuIuGtTvwzjfClGXad6PeTXvhYAIM+ZPUIUz4jIFGvEpauvhvEXvwArKQEzGLjwzMvjXhjxenI8HihlZRBPnoR81lkQc3MhnjrFe3vy8hD4xS9g+vjHeYmfOsp2o8EYwpdfjtA3vwkhFILxYx+D/uWX+TFyOBD8zndg/J//gf7//g+G3/8euueeg++vf+X3mAWgDAYnUxrec3JyUF5ervVveL1euFyuqP4NNbuxkv0b1IMxn3hBdEdHB66++mr09/dnjYHeSpBMBsPr9abFxZsxho9+9KO455578Nhjj6EmnvHvIsiyjMbGRrx27nsvVUhgLBG1JEqdEpVIXIRCITQ2NmJmZgZHjx6dN5t/MbJRYMxbs6LwCTiRO/W5uXzX/9lnobz3vfAFAqg7eRL66Wm8+qWXkPPww5AvvxzKe9/LJ0NFIAwPc3HR1sbds1/9aiiXXw7hgQege/RRXmYiy1DOPhviSy9BaGwEnnwS8g03gL3xjfxF/H7o7rsP6OuDLhBA7qOPAuefD7ZvH58OdeIE2OQkhJdf5uKlogJs507exP3CCzyIN5nADh/mGZhgEMJLL4HZ7Xx3u60N7IorwNRAWFEgPP88DxKvuALo6+M/j7NTrcIYQ39/P06dOoVt27aBMYbp6WmejbBaoRw4wHdfBwchNjXxjMZPfwrlda/jjzEaeYZkFVmJHgzVH0aSpAUb2hcjnvhZLDhYyZIvVliI4Fe+Ann3bj5uddMm6B99FMYf/xjm978foY99DOF3vIOPwv3MZwC9HvpHHoHg90PX0MB34+eGEMgXXQTDrbfykqFweMH39VZXw9LfH1VOlS0wiwUCY/xzx8sYMQbD449DbmqC9IY3IPi970F65RVeNmmzgVVWQvfIIzz7oygQOzthufRS+F5+OWEvRqYE1ZlAJh4LQRCQm5uL3NzcqP4Nt9s9r39DLbtKV/8GlUjNJ7ZEaj0Y6KWLVHswlsOHP/xh3H777fjLX/4Cm82G0bmSUIfDAfNcFcjb3/52VFRU4Fvf+hYA4Ktf/SrOPfdcbNu2DR6PB9/5znfQ19eH9773vUtaAwmMJZBsSdTk5CQaGhrgdDpx4sSJJY1fS3YiUyYRlcGQJIj/+78Q6+shff/7POgFIN5zDx/fOjEB/9NP45VXvxr5+/dj3/33Q/f3v0OYnITuzjshzMxAnjv5AXCxMjTEy6xKSnjQIIqA2w129CjY4CCYIIAVFUE5cADCpz/NhUhBAcSnnoL8+tfznd2pKSglJRBPnQLT68FyciDu2AFmsUA5fJg7gm/dygVEUxPPhIgi2N69EOrr+Y5nURHYRRcBjz8OFBRAkGWI3d0Qxsd5psNu549TFIj33MPLV8JhCI2NECQJEEUoF18MdvjwvN1zSZLQ1NQEt9utmcb19fXx4yoIvDk8P59nU3w+CM8+y5vNKyr4z9eIdAfkbrcbdXV1KCgowN69e5flbrrUta1YiYzRCOkNbwAAyNu3AzMzMPz0p9yDBYDhv/4L8vbtyPnEJyDMzPDSwKkpLtb1egS/9z2eNTEYgNlZWC67DMLYGKDTQSkq4iVEcdZucbn4qOb+/pX5XCsIKy3l5pcABFmOn6Xx+2H8+tf5sc3Nhel734P/9tv5uOnHHkP4wx/mgo0xQK+HdPXVizZ6Z1pQvVZkosCIJbJ/Y8uWLVH9G11dXfD7/bDZbFp2Yzn9G1QiNZ/IYxJpoHfo0CHcdddd68JAb6kkM7DH5/MtOUMfya1zXkyvfvWro37+q1/9Cu985zsBAP39/VHnr9vtxvve9z6Mjo4iLy8Phw8fxjPPPIM9e/YsaQ0kMFIgFW+Lrq4u9Pb2YteuXaisrFzyTTmrMxiMQf/hD/PpTT4f9B/6EKSvfpUHwbIMDAwg0NcH1+bN2LF/P4r37AG79lrgscf4dKacHD75SGVsDOIDD/AxsD4fWEkJhN5e6P76V7CXX4Zy+eWQP/QhHnRJEoSHHuKlJkYjhFAIyv79gM8H4bnneJP1rl1g/f0I+/3wnXUWHNddB6GzE7r//V/ev3DBBbwBeNMmYGYG4v33c4fx0lIolZVc7BgMYJdcAgBQVO+MzZt54/mrXnWmXKmsjPtwBAIQOzq4oJBliDod5H37opqDZ2ZmUFdXB5PJhNraWi29HxUgq7WUmzeDTUzw0prCQp7RWOFJUQuRrh6MyOzNjh07sHnz5mUHNivt5L0cxIYGCIODkK69FoZf/QoAIF1/PVBSAkGS+PQqUdTOOYRC/BqaOzf0jzzCy/MA3suh1/MJVxMT84JwYXr6TK9CNpVRzX1+wecDMxr5YIiREe3nGoxBOXAAhl//GsbvfAeYnYX5yiv557VYEL72WkhveAN0L77I+2iOHJn/XlNT/DpaQ2f6TCQbBEYsyfZvqCVVqfRvUInUfNQSqVgDvd/85jdp2ZnPZmRZhnFukzUR6erBSOa+9djc4AuV73//+/j+97+/7PdWIYGRJIwxSJIEaS4tn0hc+P1+rZzj3HPPhW2ZwV42CgwtgzE3iUn3xz9yMzCTCSgrAwD4tm+HVxCAqiqUbNsGcU4hs6IisIMHwSQJwvAwmChCaGjgzdE+Hx8V2tLCPSpeeAECwKfvVFdDqKwEO+88wO2GeNddEJ96CoLHw8uUSkrATCaIjz3Gm8InJsBKSyF997vo9XqhWK1wMAbd73/PS52efx7o6eG9EpOTEEQRSnExMDvLS5PieC6wyy6D4vEAIyNAVRX3wRgaAsrKeDA0Vw6llJfzNYTD/LUixIXaxFxdXY1t27ZFnWMJe1sKC6G84x38dYLB9PwRl0g6SqRkWUZzczMmJye17E06SBQILLTe1Qge9L//PYy33AIhFIJ0wQUIfuYzgMkEZe9ePpBArwfKy3lZjyzzoFeWYT3vPHhfeYVnQl73Oh5Mh0Lc5ToYhLDQJLdsDJoVhU9+Cod5GVgwCJabC0GSEPrUp2D84Q/52GudDqG3vx2spATG73wHgtfLxwjPTdUy3HUXfHffzQ0v4zR5C6OjMF9xBaQbbkDo3/6N/4yCSDDGslJgxJKof8PtdqO7uzuqfyMvLy/hMBb1vkEZjGhkWcZtt92GH//4xwA2hoFesiSTwfB6vcuOGzMFEhhJoGYt1OAu0Q1ldHQUTU1NKC0txe7du5dVzqGSjQIjcs1s1y5tIo5y7rmAKPLjNDqK6g9+EFvOOQdidzd03/kOlPPPB9u5E/JHPgLxjjsArxeGT30KSlUVlDe/Gez4cb4LOTnJdy51Op6hKCjgnhMXXggAEF56CeIdd3BzO68XQm4u5LPOArvgAjBJgtjeDsFg4Dv+e/eCtbdDMhh4X0hXF28ilyRu2Hf4MBc3jIHJMvewGBsDior42FyTifc7ANw0sLKS/3c4DKGtDeKDD0LZvx/s+HEob3oTf9zgIITcXIhNTWAOB6+hVxS0tbVhdHQ0uonZ44HQ1QV2+PDCzfPqztAS+xPSxXJ3/H0+nzbnOzJ7s1JrS2atK7qDrSgw3nILN80Lh6F/6imEPvc5fh7NEbj9dogvv4ycz3wG8Hp5FkyWAYsF1gMHELj1VsgXXAD5Va/izvRPPMEzFOEwP7+MRn4tZBNzQayyaRPEiFIuIVJASxI3wNTrYbj9dvh/9jMou3dD197OyxyNRi44Cgv5BofRyHvn9u0D27qVv0bMPVr3j3/wkjSPB4af/hTiK68AN9644h83G1Cvg2wXGJEs1r/R1tYGs9kct39jsXhgIyLLMm6++WbcddddADaOgV6yLDTCV2WhMbXZBgmMBYgsiVpoSpQsy2hra8PIyAj27duXNpt1IImRrxlIZN8IO+ccSEeP8myGLKO9tRVDQ0PYt38/SktLITz8MMT77oPQ3Az9H/4AduAA5Ne9DsLICO91EEUIkgTx0UfBpqYgDA3xkZ5DQzyAKiyE8sEPgh06BLZpE8Tf/x5CSwsvDZmeBoxGyMePg11wAX+ezwds2QLlrLP46MoHHoBzZAQThw8De/aAbd7MJ/CIIlhtLZR9+4BXvQrIzYV4770QnnqK1677/RD//Gews8+GcvnlXPzo9Vq5lHDyJH98dzfEvj6wkRGeZQBvUheGh4FwGOLLL8MvCHh5rjH3+PHjWhOzcOoUxAcfBFwusKEh6HbtyvhzYTkCY3x8HPX19aioqMDOnTvT/sWdkSVSoojQ5z8P0xe/CCgK5MOHo8QFMDeeNjcXzOmEEAjwRmeAB81OJy+xA7hpHAD9nXdyx3EA8uHDvCQvGOQ7+TGN0Sw3VzMKzBgE4UwJ4dgY/9ySxMuiioogdnVpk7OEOb8LxemE/LrXAYIASZ3wFQoh+JGPwPSDH/CMUHk5wm97G9jmzQnfWq6tBTMa+esyBum66+Lu2gvd3RDCYSiq180GYD0KjFgS9W+43e55/Ruqued6Ph6pEAgE8IEPfAD33HPPhjPQS5Zkm7wpg7HOSbaRe3Z2VhshupwJN4nQ6XRaWVa2ECWK5gzAfD4f6urqACD6OFVUQJiYgNjZyZu1JyYgtreDORxgtbUQn3+e70BarXzc61//CrG5mTdjHz3KpyldfvmZaUxWKzA2BlZcDJSU8ABg61Yt8IfDAeXqq3nz+d13A319ME5OwhYIAIcPQ37XuyC0tgKBAG8Mf+gh/t7nnQd29CiEF1/kZShjY2A+HwSrFeKTT0I+ejRq3Czbvx/4xz+A6WkILhfY1q0Qnn0W7NgxsD17INTVAZKE6VAIL05OonjTJuzevTsqqBZaWvjY3dFR3qC6aVPG14MvpQeDMYauri709PRg7969KI9TfpautS1FYKw08pEjCH7xi/w8T1CjzCoquIDdtIl7OAgCoNdDKSnhGbwIpKuu4oFybi4QCiHnC1+AYDZD2b8fYmMjxLo6bdIUczi4X8zYGO/rmAvsVw3VMDDi78JKSs6Y4EkSpOuv56LK64W8Zw907e0QJiage/BBMLsdEEVIb3zjvEZt4fRpmH70IwiTk0A4DN3YGMTTpxH43vcSr8ds5mWLjPFejpqa6HOGMegefRQ5n/zkGUPEyy6LO+J4vbERBEYs8fo33G635jAOAE1NTVrD+Gr5b2QakQZ6er0eN910E973vvet9bIyjsUEhlqyl+44cq0ggREHNWuhprMSeVsMDg6ira0NVVVV2LZt24qkSrM9gwGcKR0rLy/Hrl27II6O8kkwlZVg5eVgFRV813Z6mpce/cu/AH4/74WYKydSbDZeGnXqFFhODjA1xbMH117LnbPnYNu3Q6io4CZaZjOUj38ccLvnL1KvB9uyhWdK9HoE8/OBnBywyy8Hu/xyYGoK4u23c/M9i4UHG1dfDeW1r4Vos4H19kKYnASrqIBy4sR8LwtR5E7eAwPcYby/n0+8OnKEj7e12zFSVobxyUnsPPvsuEG1cu650NXXg5lMXORUVkJpb0/b32klSLUHIxwOo6GhAV6vNy09S4uRUVOk1NevroaUxNhG75NPcgGiNmhbrdwzIxaDgQuSQACWCy/k15vPB11dHeSDB8+MsTUYgJIS+B59VNsIEJ9+GpYIB/F0wgwGPvlJrwdzOiFv3w5xcBDC6dPRpoBeL2A2g8kyBJMJwW98I6qUSffZz0L36KMQZBksFELgv/8b8kUXQf+HP3Cxce21/P0qKyG/6lXQ3X+/lpUUZmehe+opLgpiyPngByHv2YPAL34B3ZNP8mt+716gtfXMg/x+5Hzyk9wckTHkfPaz8J1zDjc5XOdsRIERS05ODsrKylBWVga/349nn30W+fn5cLvd6OnpgU6nS6p/Yz0Ra6D31a9+FVes0D0k20nWB4MyGOuQZL0twuEwmpub4Xa7cfDgwRUdu5atPRiKokSZo+3btw+lJSUQTp6E7kc/gtDTA+k73wE7ehTyf/wHlLY2wOvl/hYPPADlAx/gfRgmEzA1BWFyEsqOHVBqarjXhSRB94c/QBgZgfylL2m9B6yqiu/uWiyA2QxhYgJMLZmIgRUXAzt2QNfbC/vzzwNvf7s2RhcOB8+KTE7y0ozzzgPy88Euugjynj28t2NsjNeAl5fz5urBQUCt7QagvP71EAoLueu3IPAMjMGAYDCI+q1bEaysxIEDBxLfTJxOKFdeCVZQACEQgCAIMPf2QvfSS5A/+tFFHYjXglSyBDMzM3jllVeQm5uL48ePr3gTYEaWSKXCXEkGHI4zP1tgKovupZd4FsPr1TIEuldeObPTbzQicOut2u674Ve/gvHrX1/edKk5oQKdjmdY8vK4wFEUCOEwmCjCX1KC3l/8AmXPPgvDpZdC19sL8wc+oAkn5nSCWa0QBwfBbDaIL70Ewz33QNm0CeEPfxjywYPQ33EHF1c2G5Tt25HzvvdB9/jjgCBA//e/I/A//wOYTAi/8Y2Q9++H6etf5/0YRiPC73539JKHhmC56CLuL/LQQzDeeiv//IKA8PvfD/aa10BQA0WLBeF3vAOG//5vAIA0d31GIcsQOzqg7Nq1tGOYoZDAiEYtndu8efOC/Ruq4HA6neuu0TmegV44HKa+lAQkIzCoB2MdkmxJlMfjQX19PaxWa9qbUOOh0+kQWmgaTAai7mI/99xzAOZKosJhCE8/Dd3NN/MeiVAI+o98BNLPfw62fz9YbS103/wmb7CenITus5/lYzdLSwGDAcqFFwKFhbw5G+AZjv5+iI89BrZ1K5QrroDg9UJ48EGIzz3H69MLCqDo9RBnZ6Fccw3YXK26RmUlxD/9CbrZWeg9Hui+9z3IH/gA79UAoOzdC2H7dsDrPWOYp9PxMbvAGWfxufG5OH2ae3Hs3atNhmI7dnA3bcYAh0PzdcjLy8OhQ4cWniiRk8MzHgAYAPPtt6Ps738HTCbovvY1yDfcECVoMoFkA3J1WlZNTQ22bt26KkFLppZIpR2fD4Y//QnGr36VN0WbTLz8yWTSBDuMRiiVlTzTN4d0wQUwfuMbZwRIiseKFRcjePPNkPfv52VObjfg93N/Do+HT34TRZhmZ1Hy7W/D+sorkH76U3T9+79jt8EAMTeX+1JccQUMd93Fr3FRhPlNb+IZQp0OhrvvRuCWW3gW0GwGs1jASkqge+opCNPTAKBlHwBAvuIKyOBjopWyMuhaW/nGQuS6Cwv5Z/b7Ieh0XJCpouvnP4d43nlRQk4+5xyevTSZIB87Fn0QJidh/O//huEPf0Dghz+EfP75wDrZxSaBEU2sB0Zs/4YkSXC73XH7N/Ly8uBwOLI6EH/xxRfx5je/eZ6B3osvvpiWATfrkWRLpNbLOF8SGICWtViokZsxhp6eHnR1dWHbtm2orq5elRttNmYwJicnAQB2ux179uyB7tQpiLfdBng8vDGTMUCSeGmU2nApimDV1RDb2oD+fh5QFBeD6XRgF17Ig3YA0k03QT8ywpssfT4wQYDQ2cnN9A4cgDg0BJaTw5tCzWY+BcZshnj77WBHj/L+CxVRBNu9G2JzMx/pabUCTueZ39fUQA2xhH/+k7t5q6IiAqGpCUJHBx9Pqyg8YFFLXgoKgIICMMbQ29uLzs7OJfs6sNJS6LxeCFNTYFVV8xzOM4EFJ12BfymrAxGipmWtAhlntLdCiN3dMH7tazzgNhjAcnIQ/uQnAUmC4fe/5+enosD35JNRwS+rqeHXREkJ78PIyQEbHoaoKDzgnjOmQyg0X3wYDAjfcAMkdVIaAN3jj8P0sY9B8PuhHDzIp6ZZLEBNDfIbGyF4vTAAKHvlFTR8+9sYtdmQNz4O/bFjOHj33ZrggNHIxYooQjGZoOzfD9/TT3Pvl+lpwGxG+LrrYPjtbwEA4X/913lBvXTVVQAAJVYQAIDJBOmyy6D/61+BUAjyoUPQ1ddrr6VYLFHXqnzeeZDPOy/usTd95SvQP/AABK8XOR/5CII33gjphhuS/dNlNCQwolnMxVuv1yfs3xgeHoYkSZogybb+jQcffBDvfOc74fP55hnoJTMpaSOiVsgsJDBCoRAkSaISqfVArLdFInERDAbR0NAAn8+Ho0ePwhkZhK4w2SQwIkuiAGDHjh38mP7zn7wPYWwMitPJTehyc3mAoHocMMbN6AYHecmBIADhMFBRAeXSS8/sIObn85G1isL9NXw+CKOjYHY7N+Hr6gKzWrmT95VXQve733EfjYsu4nPvY2BVVZA3bYLXakX+vn3zHX3VXoyeHsDpBDtwgJvtRb7G4cNgzc0Qiop4aVZMPX04HEZTUxOmpqaWdf6w8nIEbTY+YtNiWVNDvUQsFMQHAgHU1dVBluWoaVmrubZkfhb7+2wTGMq+fVC2boWuqQnQ6RD88Y81x/Dw9dfzRvE5ARGF1wuWm4vgj34E+cAB5Lz//ZACAeS4XFDKywGjEaEbb4T+zjuhf+QRniVUMRgQfs97IhahcHExO8szF93dCPz4x1DmRj6br7qKX9MGA3L+4z+wvbISW2RZc1zuvO46eJxOFE5MwDk+jrwnn4QgCPxzCMKZjOJcBib8nvfw3zHGBVKKBD/zGSh79sD4zW9CdLkQ+tjHeH/Vjh2p9RR95CNcqIgiz8a8+c0pryVTWchcdiOSqsleZP+GulOtCo6enh6IoqhlN/Lz8zO2fyPSQO81r3kNbrvttqgdd3I3j4+68baQwJidnQUAymBkO7HeFolunBMTE2hoaEBBQQEOHjy4qElKuskWgRE5Jer48eN48skntXUrr30t/j973x3eVnm2fx8Nb8uy5b1nEjvOchLHNgkkIYtOSpiFAp3sFvi+tqyyoQXKr5RNW8oqUMr82qbNBDIgJCSW5L33tiQvydY85/eHOC+SLMmSrHEk676uXt9HbFmvjs547ve5n/vmyWRml6isLBivuw78//s/88zC4KA5RKypCbz9+827qyIRMDEBZtMm8yAqe7GZTGZXJ5XKbL0JACIRGIoCr63NPEgdEwNm+XIw3/42eAcPAuPjQEQEeHI5TLY76wwDprAQ6ptvRk9bG7I3b57/wQQCUBMToHp6zO/1lTzKClFRYCorzY42Nt/V9PQ0ZDIZYmJiUFNTs2CKp1NkZaFz717kfuMbAQ/UcwRHBblKpYJcLodEIsHKlSsD0kIP+hkMN2C45hoYlUrw+vrMTmoMA15rK2J274Zxxw7oHn8cjEXAI/8//0HUDTeA0ukQ/f3vw3D11dC+8QZOnz2LDa+8AuH3vgfT+ecDfD6MF14IXlMToi+7zHzNAaBXrLC21+XxoHvwQUT9+tcAnw9TVRWMl15Kfqy75x4wqangtbWB+Ypw8/l8SCQSSCQS4NFHkazTmYuv3l5IL74YlE6H2JwciAcGkJSUhOjoaHLPZvLyzHMeer1TG1pHENTWIuLRR0Gp1aA6OsA/eRLad94x/7Cx0WEhyTt9GpReD9NX9w4mMRF0SYl58yQuLmTkUUBwpnj7EosppC3zN3JyckDTNKanp6FSqTA8PIzW1lbOzW8wDIP/9//+Hx544AEAwBVXXIFnn3123rrYJO8wrMHWQ86OjUajAUVRYRepYIWr2RY0TaO9vR19fX0oLS1FVlZWQG6uwUAw5rlE8XjWTlJJSaC/+12z9lmvB/+110D19gJqNfjPPAPTLbeAKSkxS5SMRiAqCqb77gOzdu083350dJjJhV5vDs4qKgIyMkBfdhl4zzwDLFtmHrxetQpMf7+5ezE9DSQmgpqYIJInGI2gjh4F7+OPIbz0UmT861/A6tVfD9KyiIgARkbMRUtMDJh16+YfgKgoMFVV8/55YGAAzc3NXpsz4PF4MERGmudAOHoDsrWpZRgGvb29aG9vx/Lly5GTkxOwIsUeWQjVgsl45ZVW/80/cgTRP/whMDsLwX/+A15rK2ZPnCA/p0tLzd07rdZMCCoqQHV14ZzLLkOEVgvqP/+B4ZJLoPv9782ZNitXQvfrXyPyK4cng837AQC9Zg30P/sZmJSUecSclQ3Zc3NiERkZiYyMDOScOQOqrQ2qn/0MKpUK4+Pj6OjoQEREBLEHTamvR+yPfwyKYTD34otuW8cav/1tRN52m3lDg8eD/u67yc/sEkyGgfAvfzEPj8PcATFcdx2YlBTM/fe/Lr9vMCFMMKyxkETKHfB4PIjFYtLddjS/wRIOf89vmEwm/PrXv8af/vQnAMBtt92G+++/32HtFO5gzIflfK8jsBa1oXL8lhTBcHWQe3Z2FnK5HDRNo7q6OqDtKi4TjHkuURZ2sVb2uvHxX8uKDAbQ09PgDw6aH+YJCUBmpln2kJdnLp4NBuCroVAr+1eDAUxFBeiZGfPPVq0yp3er1STkjpZIzBaSPJ5ZivVVzgYUCvD27QPq6mC64Qbw3n4bvFOngPZ2JB04AF5UFPiPPAL60kvBrF9vfr+uLvDfessczhcXB7qy0mw9uwBMJhOam5sxOjrqVZexYNhNtyQYRqMRjY2NUKlU2LBhAxJZOVwA17ZUOhi2MJ13Hhg+3xzQR1HQ/+IXVj9nCgrM12BiojlZftUqIDYWfL3ebCFrMpmvKwsYf/ADp/MFdHk59F8ZKwhfew3Re/di7v33XV80wyDyF7+A8KOPAJMJafv2QfT3vyNv3TqYLORUvS0tyL76ajA6nfk1110HzalToDIyzHMnL7wAww9+YD1fZQuKguEnPwF0OvD6+uYNgs97TszOmgfiNRoAQOTvfw/D979PJFuhiDDBsIa7Eil3YDu/ofuqm6dSqdDY2Aij0QixWEwkVXFxcT5bi06nw89+9jN8+OGHAIDf/e53uPHGGx3+fngGwz7Y+Qtn35NarQ6qWZyFsGQIhivZFoDZ07mxsRGZmZlYvnx5wFt9XCUYDoPzvoJtFgYAsw3tG2+Y8y1ycsBkZJgtZL/6Lugf/hCYmAD/iSfA+/vfwahUoM89F0hKAtXYCN6+fTDt3Qvm2mvNu5PR0eaiQa//2gYW5lkFAGDKymB64AHwn3wSlFQKqr/fXEAJheaOwxdfmAsnmkbE9LR5kNRS0sDnAzMz5rmQiAggLc3swrPAcZFKpeDxeKipqUG0hQxlsWDdubj8oGfXqNFoIJVKIRQK/eK25gockQVnxzJUCAYEAhi/+13wa2tBDQ2BtmPdPHvqlDk1e3ycdBzm0tIQOzYGHkVZDXC7g+iLLgL/1CnAaERcTg5m9+8350vYA00j4uGHzYnb+fngnzljJvgmE3gdHcSa2UpOVVIC0/XXQ/jss2AYBsPr10PW1obM06ex7E9/QoRUCuHLL0P33HMwnXOOw3Xq77zT7r/b/f5jY2G4/npEPP00AMBwySUhTS6AMMGwhT936tlunr/nNywD9IRCIV566SVcfPHFDn+ffT4Fum7iIlyRjoWSRS2wBAgGwzDQarVWrSd7N0nLXedVq1YhzYNBQV+AiwTDniTKFvMCAhkG/AcfBDUwAKjVYOLjwVRWgvfFFzBt22YmDOPjEPzqV+aUa60WDEsINBrwX3jBHBamVoP+znfAVFaa/65CAf4f/gD6ssvMBMPyu6UoIDIS9IYN4M3MmJexfr25u5GYaJ73SE4G8/nnmExKQlxcnFmqxSIvzxz4tXat+TUO8jRYjI6Oor6+HllZWVi+fLnXHz7s3+OyxpWiKBJAlZ2dTQb9uYKQIAseQvfUU05/zu7aW8qZGu+5B5nLliH5q6A6/n//C5ObIVp0Vhb4er1Z7hgZCdreHBMAXksLoq6/HrzWVkT85S/QPv44DD/+MSLvuw8AYKqqchxoV1MD0+AgmOhoJG3ejIqKCpheew1RZ86A0mpBDw5i4h//gLakBImJiW7r2e09M4znnw8mPt5so11a6tbfC0aECYY1vCmRcgeuzG9ERUUR+aCn8xu2AXpvvfUWzjvvPKevYZ/5XLrncwWuZGCEOxhBBFYSpVAo0Nrais2bN9v94mZmZiCXy8luqzd3nRcLLhEMZ5IoW8yzK6Uo0Dt2gP/qq+b/7OoCb/9+UAoF+HfcYc6fyMgAk5kJ6uRJ82siI8GsXQv+M88AKpXZdlMuB/O//2v+GydPgvfOO6AGB8H/059Ab98O2s4uK7NlC0wbN5K/CQBIS4PpoYcAisJsYyMau7qQUV5ulm1ZwPSjH5mtZkdGHEosLOd1ysvLkZGRsfDB9ABkoJWjRTLDMFAqlZiYmMDq1at9dhw8xVKVSAlfeAF0SQlMO3a4/dq5nByY0tLAO3oUUT//OUDT0N96K/S33GKemQIAnQ5RP/4x9HfeabczYTr/fAg//BCIjIRp9WqH1xGlVILX1mbuWERGgn/mDHR33gm6rGzBpGzT+eebh9C/QjwA3Hwz+L/7nTmhnMeD4sorMd7dTQomtgBbSM/u6PunN24Ezd5XlgDCBMMavpRIuQN78xusfLCrqwsajQYikcit+Q3LAL3U1FS8//77WLNmzYJrcWXOYKnC1RTvcAcjCGCZbSEQCGAymebdDBiGQX9/P1pbW5Gfn4+ioiLOXRis1CjQN/eFJFG2mEeMvgr3YrKzzUPYPB547e3mpO2CAnOgXkyMOYl79Wqz531+vtm5KTMTFJ9vLjKSk0mBwqxcCURGgpqeBpOaCvqrULp5iI4mwXdWYI9nQQGM/f1g7GWbsI40DgLttFot5HI5DAaDz+d1LDsYXINer0ddXR1mZmaQlJTEOXIBLD2CQSmV5oTrzz4zDy7/7GfQ33//fCvmhcAwZnKh0wEmEyL++EcY9u4FU1IC/rFjiL7sMsBohODIEejuuAMGm/kO47e+Bc2GDWASEsx5Mw5gOuecr6WPPJ45cVsigam62oNPb4bu3ntB5+WB39yMwjVrUBgZOU/PbjKZrPIIYmxyL4DQNQNwB1wpqLkCrg4zCwQCJCcnk9k/9nyfmJhwaX7DUYCeKwh3MBzDnQ5GqCDkCIZltgXbwhQKhfO6AGw2weTkJCoqKsxaXg6CtcUNpCzGFUmULaw6GD094D/3HDA3B/pnPwNTWgr094N68UVzynViItkNpS+/HPTmzeA/+ST4n38O5l//AlNUBOZ73wN6e83F0fS02e1JJDJLLiorzUPfCQkefT72uLpL4pRKJeRyOZKTk7F+/XqfWxhzlWBMT09DKpUiPj4eBQUFmJycDPSS7MKT4iioCyq9HvzPPzcTAx4Pwn/8A/r77nObYDAAtE88gajbbgN4PJgqKoiUkImPB2ja/B5sEJ8tBAJiYbsQVZv785/BZGWBV19v3mBYJAw/+xkAa7cqe3p2lUoFhUKBzs5OCIVC0t1ISkpymWAKX3gB9PLlMG3fvuh1cxGB3uTiGgIlkXIXtuf77OwsIdjs/AZLrs+ePYuf/vSndgP0XIEzZ86lDleG32dnZ0MmAwMIQYJhzyWKz+cTwkFRFCYmJiCXyxEfH49zzjlncdkEPgZ7QrrCfr0NdyRRtiAdDIYB/5lnQHV1AbOz4D31FCAWw/TLX8J0333moWrLXU2RCIL/9/9AnTkDanISgscfh/Guu8whfKOjoMbHwX/ySdBXXAFmxQqY7r/fvOvJpg17AMvC3ZUHhmWquz+tV7kokRocHERTUxMKCwtRWFiI/v5+Tq3PEkslyZsFk5EBU2Ul+F98AQDQ//KXHl8j9Pr10P/iF2AyM63kSvS6dV93HSjKSqbkCdj5Dnr16kX9HVdhqWfPzc0l7lQTExPo7e1FY2Mj+Hw+GIZBbGysXXkJpVQi6mc/A//YMXOn6MYbzUQuxBAmGNYIxo4ORVGIjY1FbGys1fzGxMQEXnnlFTzxxBPEPfPFF19EgpubdmEHKccwmUwLbkKGJVJBANvQPPYBQdM0enp60NXVhZKSEuTl5XH+BsGSCn/PYbgribIFcZGiKNAXXgj+iy8CSqWZaGRmgv/734P+9rfBbN06T75kuuIKCGprzc5NMTFgLrgAaG8Hdfas2ac/NvbrVG72ZraIm5o7nQGDwYC6ujqo1WpUVla6fQNeLObNtgQINE2jpaUFw8PDWLt2LbFTtM3B4BKWmkQKAHT33Wd2YBodhYm1X7aDiMcfB7Ra6O+91+7P6RUrrLIhLDH7n/+Ayc0Fr6UFtKVJgiegafBPnnTq9uQpqPFxUMPDTsmLlTsVzPISuVxOLJdNJhORlxA5lVYL/okT5o0SHg/Ct982H0eOP1vcRZhgWIOrEil3wOPxkJCQgJdffhmPPfYYAOCiiy7Cr371K4yNjaG7u9uteaVQOCa+givkS61WhzsYXAZrk2kJljV++eWX0Ov1ASkMPQX11YCiPwmGJ5IoW1i6SDGZmaC3bAEoCtSnn4KnUoHJyjLPUACAVAqqqwvM3r3m38/OBlNWBiYuDkx6OsDng0lKAlJSwKSng0lLMwfgeQmuEoypqSnIZDLExcWhuro6IJ0vLhAMrVYLmUxGdrosySeXC/KlSDDor0iFwzNGo0FsdTWowUEAgPCNN6A5fdosW3T1Pb4Kn5xHClQqRP3v/0L32GNgviKgzkCNjCDiD3+A8C9/ge6BB7yaK8GTShF98cWgpqYw98Yb5oF3F5x1IiMjERERgdTUVGRkZBA5lVKptJJTrVq1ClEymTlj5I47Qo5cAGGCYYtgkUg5g8lkwh133IGXXnoJwPwAPXfnN7jscBhouNLBmJ2dRXx8vJ9W5HuEHMGwdwNUKpUAzA+LDRs2+Fwr7234y0lqMZIoW1iRoqIi0EVFZk14fz9ogcBsWZmYCN7rr4P/+uvA7CxMDQ2gf/5zYPlyGP/2N+s/mJoK0x13WP+bXg+qvh5MRcWiHuhsx8tR4c4wDAYGBtDS0kKkQFxKo/YnVCoVZDIZUlJSUFZWNu9hYo/gcwVLTSLlEqKizEGVX8kZqclJwGIHzdPzXLBvH6J+8AOApiH46CNoX34Zxu99z+lrIh57DMLXXgNMJkTeey8otdpcrFtCo/navcpVMAxidu0y33NoGtE/+AFmDxwg5Gvhl5u/f3tyqqmpKahUKjRcdRXmLroIibOz4C1fjviJCb+nLfsaYYJhjWDfrXclQM/R/MbExMS8+Y3ExMSwRMoJXDk2Go2GkwYpniK4Km03QdM02tra0N/fD4qiUFxc7JBcjI2NITk5mZMXx7xMCR9gsZIoW9hdc0SEee5CKDSndZtM4H34IaieHjP5+Phj0D/6kWu7pwMD4H/4IdDcDKa/H/TWrfbtL0dGQLW1gTn3XKd/zlFnwGQyobGxEQqFghNmAIHqYDAMg97eXrS3tzudOwk0AVoIS62DsSD4fBiuugoRzz8P0DSMmze7tLM/DyaT+ZpmA760WvNcFHuuzs0t+Cf0d90F4euvmzcLbNPGaRr8gwcRfcUVmP3kE9Br1ri+qUBR0D3xBCJvv92cZ5OW5jK5+PpPzH8vPp9PpCMoLoZOpyPhZ32O5FRBXKCHCYY1gnEGg4W7AXqA/fmNmZkZq/wNoVAIhmEwNjbmUd5MKMNkMi0YOMvmtYUKQpZgaDQayOVyAOaC+fTp0067AHv37kVfXx927dqF3bt34/zzz0eiGzIBX4IdUvcVvCGJsoVDWRd7w/nq/9Lf+hao3l6ApsGsWAHk5Lj29z/7DNTp0+Z0bqMRTGoqmJoaq9+hvvwSvLffBjU5Cbq7G/SFFzp0mrJXuNumUXsrHXUxCMSMg9FoRENDAyYmJrBx40bit24PoTiDEerQ33YbmPR0RN55JwQff4yIBx+E/tZbzS5trsBgQNSNN0Lw/vtQDw4C0dEwfvvb5rmor46f8TvfWfDPMNHR5jC9hARQlmQFQOQvfwnhyy+buxFbt0J/zz3Qf5WH4wpMZWUwVVaCyc11OxTP1XMmMjIS6enpSE9Pt3KnspVTsbu9XDYXsYdQkAR5E8F6PEZGRrB3717U19cjPj4eb775JrZu3er232HnNxISElBQUACj0Yju7m6Mjo6i2yZvJjExEQkJCUtaPuVqDkZ4BoPDoCgKQ0NDaGxsRHZ2NklUdiYzUqvVaGlpwczMDN544w288cYb4PP52LRpE3bv3o3du3djzZo1ASs2fNXB8KYkyhaukiJm0yaYdDpz3oWDhF97oPfsAfXxx+a5jJgYMHa88nlHj4Lq7ASlVIISCoHzznNKMCzPj5GREdTX1yMnJ4dTadT+liCxJCsiIgI1NTUL7sCEJVJBCLEYkXfeabaZBRDx5JMwXnwx6LKyhV/LMIjLzgb1VYciPi0NmmPHQK9Zg7k33wRdXg5efb1rsqa4OMzt22f3R4Yf/YgQDPB4MFx6qcsfDwDoykrM7d/v1msWA2dyKtadyp3hWS4g3MGwBpuxFUzwNEDPFQgEAsTExCAuLg5r16616ug1NTWR+Q1WUmU7vxHqcIVghG1qOY6hoSE0NzdjzZo1SE1NJf8uEAgcFrxxcXEYGBjAZ599hoMHD2L//v1oaWnB559/js8//xz33XcfMjIysHPnTtLdcLaL6234YgbD25IoW7gq5WHKy8GUl7v/BpGRYHbsAJ2UBEqrtSuXoL/zHfAbGsDExJiJhRNffXa9lqRr9erVSEtLc39tPoQ/JVJjY2Ooq6tDdna2yySLy5IiT3MwuPp5vAaKgvaFFxB1ww0AAHrlStfIxVevNXz/+4h4+WXyT/TKlWbL2q8sZ00udiWdgc7IMF/jbGaNF/6mO1hsIWQlp4I5mNIy7M9oNJLCi6tyqjDBsEawSaRsA/Q++OADFBQUePU9LOdSbDt6lvMbPT098+Y3ou2F4YYQwkneIYD09HTEx8fPk7MsVKRHRkZi+/bt2L59O373u9+hp6cHhw4dwv79+/HJJ59geHgYr7/+Ol5//XXw+XxUVVVh9+7d2LNnD1atWuXTG423CYYvJFG28PlgelQU6EsuAeA4vItJT4fpqquAjAzrrA074PF40Gq1REpXXV3NyQvdHwSDYRi0t7ejt7cXq1atcquzxeWCPCyRcgy6ogKGn/8cdE4OGJvNk4WOmWnzZuArgmG46CLPZjgWQlIS1AqFmWB8ZX/tL/jifI6IiAg6OVWYYFgjmCRSBw4cwDXXXONxgJ6rcDT47sr8RlRUlBXhCLX5jYUIBnsfCHcwOAwej2dXK++sg2EP+fn5+OlPf4qf/vSn0Ol0OH78OA4ePIgDBw6gtbUVn332GT777DPce++9yMzMxM6dO7Fnzx5s377d6xa43irWfSmJsgUX7FQhEoHZscOlX6VpGs3NzUhLS7PrjsQV+LqA1+v1qKurw+zsLKqrq92+2YXaDAawBCRSMOdc6B56yKPXGvfuxcx3v2su/n353bPXZACuTV8W1sEipwoTDGsEi4vUm2++iZtvvhkmkwnnn38+3njjDZ8Vsa7a1Nqb32ADLkN1fsPVDkbYppbDcHQDXEyRHhkZiR07dmDHjh14/PHH0d3dTcjGp59+iqGhIbz22mt47bXXIBAIUFVVhT179mD37t0oLy/3Snt9sQTD15IoW/jLWnexYBgGnZ2dmJubQ3Z2Nso9kWv5Eb4kbmzOh0gkQk1NjUf64lCbweByR4ZTYM+VIC8C7MHfhTVX5VRhgmENrkukGIbBH/7wB9x///0AgMsvvxzPPfecTzsDntrUCgQCJCcnk66K5fxGc3MzDAYDEhISyDkfjPMb4SHvEIY3nZgKCgpw3XXX4brrroNWq7XqbrS1teHEiRM4ceIE7rnnHmRlZRFnqu3bt0PkqjOLzdoXU6z7QxJlC3+HA3oCy936+Ph4zriGOYOvCMbAwACam5tRVFSEgoICj2/eXC7I2c9kWSjRNI25uTmHRVqwPcTCCD24IqeyJBy+klOFCYY1uNzBoGkav/71r0mA3q233ooHHnjA59+ft46JvfkNlnBYzm+w530wzG+4KpHiojTbUywZgiEQCHxS8EZFRWHnzp3YuXMnnnjiCXR1dVl1NwYHB/HKK6/glVdegUAgQE1NDXGmWrlypUsXvKcEw5+SKFv4I7tjMZicnCS79dXV1ZDL5ZxeLwtvF/CsNGxkZATr1q1btC6XywSDBVso6XQ6yGQyTExMIDIyEklJSZBIJFb632D4PL5EuKDklkTOmZyqr68PTU1NZLMkKSkJYrHYa0Uw13fs/Q2uzmDodDpcd911+OCDDwAAv/3tb3HTTTf55b1pmvY6wbWc38jOzraa3xgZGUFbWxu5f3N5fmMh+djc3Bxomg5LpLgMZxIpg8Hg8/cvLCzE9ddfj+uvvx5zc3M4ceIEDhw4gP3796OjowPHjh3DsWPHcPfddyMrK4uQje3btzs8sfh8PnQ6nVvr8LckyhZc7WAwDIO+vj60tbWhuLgY+fn5oCiKGzMjLsCb69RqtZBKpWAYBjU1NV7ZBeLycbS8N0xNTUEqlUIsFuOcc86BRqOBUqlEd3c3GhsbIRKJkJSUBKPRyNnPE4b/wNXC2pmcirUGtdzpjY2N9fizhDsY1uAi4ZqamsKVV16JY8eOuRyg5034I8nb1fkN9pznwvwG61DpbB2zs7MAEJZIBSMEAgHmXEiT9Saio6NJd+P3v/89Ojs7iQ3u0aNHMTg4iL/+9a/461//SsLcWMJRVlZGbl7udjACIYmyBRc7GJaBcevXrycPZYDbhbElvLVOpVIJuVyO1NRUlJaWeu0GzOUdf/Z6GhwcREtLC4qKipCXlweDwWBVpGm1WlKkKRQKMAyDhoYG0uFYKAsk1MDV79NfCKbPb09OxUpLurq6IBAIyLnurpwqTDCswTWJlLcC9BaDQBwTd+Y3EhMTER8f7/fzmH1mO3vOqtVq8Hi8oJB7uYqQJBj2ihwuDB0XFRXhhhtuwA033IC5uTkcP34c+/fvx4EDB9DZ2YmjR4/i6NGjuOuuu5CdnU3IRmFhoUtrD6QkyhZcK9jVajWkUikiIyPtBsZxbb2OsNgCnmEY9PT0oKOjAytWrECOl/MEuEww2HW1trZi7dq1SElJsfudR0VFITMzE5mZmRgYGMDIyAhiY2MxNDSE1tZWxMTEQCKRcGZ3LAzfIxgLa0s5FWsNOjk5CZVKhf7+fjQ1NSEuLs7KnWohjXgwHgdfgUsSqfb2dlx00UXo7e31eoCeO3DVRcqXWGh+g6IoQjb8Nb/B1m/Ojg07fxFK11hIEgx78OaQtzcQHR2NXbt2YdeuXQCAjo4OHDhwAAcOHMCxY8cwMDCAl19+GS+//DKEQiFWrVqFSy+9FLt378aKFSvmnYSBlkTZgguEjgWb7J6Xl4fi4mK7D4VgIRiLWSfbwZmcnMTGjRt9EhbJVYKh1+vJ9bFx40YrK2lnN3SKoiAQCFBQUICCggIYDAZMTExAqVSS3TGuB6SFsThw8Xz2BDwez66camJigpzLYrGY/I5tsRMmGNbgikTKMkCvsLAQH374odcD9FyFPyRS7sDZ/Mbo6Kjf5jfY4+LsfFGr1WGCEazw1ZC3t1BcXIzi4mLcdNNNmJ2dxbFjx8jsRnd3N2pra1FbW4s77rgDOTk5xAZ369atUKvVAZdE2YILBTtN02hpacHw8PC8ZHdbcGG9rsDTnAnbDo6vnGZYm1ouFSPT09Oora0lDm72dqwcrdeWMAmFQqSmpiI1NdWuo09ERITVsLgnVr9hcA9cOZe9CVs5FZu07EhOxaVrmgvggkTq4MGDuPrqqzE7O4t169bhvffeQ0pKSsDWw4Vj4gz25jdYkwRfzm+4YlE7OzsbUg5SQIgSDK5KpFxFTEwM9uzZgz179uD//b//h1OnTuEf//gH2tvbcezYMfT39+PPf/4z/vznP0MoFKKsrAzf/va3cfHFF3PmAcDn88EwTMBuOHNzc5DJZGAYBtXV1Qt2dIKFYHiSMzE6Oor6+nrk5OSgpKTEp9+HPSvYQILtXrHzFocOHZp3/JytdaHuhq2jDytBYbNVRCIRkVMFQvsbxuIRKh0MZ7CXtMwWXqycSigUIioqCiqVKiwNROAlUv4M0HMVXJBIuQOBQACJRAKJRALg6/kNy65eQkICIRye3sNd6exoNJqQ64CHJMGwB3eTvLkCiqJQXFyMCy+8EOeeey5mZ2dx9OhR7Nu3D/v27cPw8DDkcjnkcjkefvhh5ObmWnU3AsWI2YspEARjfHwcdXV1SE9Px4oVK1xOFtXr9X5Y3eLgDhFiGAbt7e3o7e3FqlWr/DKTY0kwAgmaptHW1oaBgQEyb8Guyd21ufr7fD6fPKxKSkqg1WqhVCqJhSir/WX/t9SGxYMZofTQdwWWOQNFRUXQ6/VobGyEXq93SU61FBAoiVQgAvRcBdc7GAvBdn5jbm6OdPX6+voAgJCNxMREl6XoJpNpwW62Wq0OOEH0NpYMwQimDoYtLNceExODdevWQSgU4oYbbgCfz8ehQ4ewf/9+HD9+HH19ffjTn/6EP/3pT4iIiMCWLVvIsPiyZcv8dkNki3pXLixvgWEYdHR0oKenB2VlZcjKynL5tcHSwXBVIqXX6yGXy6HValFdXe23GxcXCAb72XU6Haqrq+eRbHfWtpiZkqioKGRlZSErKws0TWN6ehoqlQqDg4Nobm4mA7YSiQQJCQlB/WAOI7QRERGB6OhoIi1ZSE7lKwkmlxCIYpqmadxxxx148cUXAZgD9O6//37O3Du4NoOxGFAUhZiYGMTExCw4v8GScUfnvasdjDDBCALYK6K5NuTtDljLV0cuUStWrMAtt9wCjUaDo0ePEmeq3t5eHDlyBEeOHMGvfvUr5OfnE7Jx3nnn+bS7wX4H/iJ1Op0OdXV1mJubQ1VVldthNcFCMHg83oJ5LmzGQ0JCAqqrq/06B2CZkB0ITE9PQyqVQiQSYd26dVaf3RPy4y1CzuPxIBaLIRaLUVhYCL1eT4bFGxsbYTKZIBaLiZwq0CYNLJbarrQ9cEXuF2iwx8EVOZU77lTBCn9LpAIZoOcqgr2D4Qy28xuWktje3l40NjY6nN9wZQYj1FK8gRAlGPYgEAgCOhOwGLAhgV988QUAxy5RsbGx+MY3voFvfOMbYBgGbW1thGycOHECPT09eOmll/DSSy8hMjKSdDf27NmD4uJirz5EKYryWxbGxMQEZDIZEhMT5xWVriKYCIazdQ4MDKC5uRlFRUUoKCjwe2HEXluB6GAMDw+joaEBhYWFKCwsdDi07ey/7f2+Lz5LREQE0tLSkJaWRobFlUolxsfH0d7ejsjISEI2wsPigUWg5X5cgSOiZU9OZZtDEGpyKtbIwl+1RKAD9FxFsM1gLAaWkljAvisbO79hNBpd6mCECUaQwpJJBhvBUKlUAACxWOyySxRFUVi+fDmWL1+OX/ziF1Cr1Vbdjb6+Phw+fBiHDx/GL3/5SxQUFBCyce6553plB9XXad4Mw6C3txft7e0oKSlBXl6exw+uYCcYNE2jqakJo6OjqKioIDc9fyMQEimWTPf39y/oFuaJC5evP4vlsHheXh5MJhMp0NhhcTYoSiKRIC4uzq8FWrjADgNwvZNjS54t5VTd3d1W6eOJiYlBOYvE3kP8cR1aBujFxcXhzTffxLZt23z+vp4gGDdwvQVbVzZ2foPtVDMMg/r6enLeR0dHW50/3pBI/fa3v8UHH3yAlpYWREdHo6amBo899hiWL1/u9HXvvvsufvOb36CnpwclJSV47LHH8I1vfGNRawFClGA4kkgB5iwALgxDuQLWZnVoaAgAsGzZMo8v3ri4OHzzm9/EN7/5TTAMg9bWVqvuRnd3N1588UW8+OKLiIyMxLnnnkuGxYuLiz16T192MIxGI+rr6zE1NYUNGzYgMTFxUX8vWAiGvR111jELMHe3ApkE6m+JlOWsSVVV1YI3aFe6Gq7+zFfg8/lWybTsg0qpVKK3t5fkGbAdjqWgdw8kwhIpMzw5DqEqp2Lvwb4uprkSoOcKaJoOuLMWV2A7v9HZ2Qm1Wo34+HgyvzE3N4e3334b27ZtwwUXXACNRrPoOubo0aO46aabsHHjRhiNRtx1113YtWsXmpqaHHZHPv/8c1xxxRX47W9/i29961t46623cOGFF6K2thbl5eWLWk9IEgx7YCU7wTLobRmcV1VVhRMnTnhtYJqiKKxYsQIrVqzArbfeipmZGXz66ack6K+/vx+HDh3CoUOH8D//8z8oLCwkZOPcc891uYD1VdE+MzMDqVRKGLo3CqxgIRi261QqlZDL5UhNTUVpaSknHs7+CtubmZlBbW0t4uPjXZ41cXdtXAgOjI6OnjcsrlQqSYEWHx9vVaCFH/DeR5hgeIdohYqcyh8djDNnzuCSSy6BUqkMeICeK2CPCReeQVwDTdOIjo5Gfn4+8vPzYTKZ0NbWhvj4eDzzzDO4/fbbERsbi/Lychw8eBBbtmzxaKNw//79Vv/96quvIjU1FWfPnsW5555r9zV//OMfsWfPHvzyl78EADz00EM4dOgQnn32WWIm4CmWDMEAgseqdmRkZF5wHkVRPiNH8fHx+Pa3v41vf/vbYBgGzc3NhGx89tln6OrqwvPPP4/nn38eUVFROO+888iweFFRkcO/6wtCNzg4iKamJuTn53t1bsRf8yKLBSvxYRgGPT096OjoQGlpKbKzswO9NAJPsjrcxcjICOrr61FQUICioiKXzwNPCEOgCYYlLIfF2QKNlZ+ww+LskKFEIgloNyuM0IIvOjmuyqnYc5orcir2WeErMs+1AD1X4OtjEswwmUxWyhk+n4/S0lI8//zzAMyzk5dffjkMBgN+8pOfYGxsDOeccw527NiBHTt2oKKiwiPiNjU1BQBISkpy+DsnT57E7bffbvVvu3fvxkcffeT2+9kiJAmGo5sg1zsYlpIoS5cowH9rpygKZWVlKCsrw2233YaZmRl88sknJFV8cHCQkA/AnEDOkg1b1u3NroDJZEJzczNGR0dJroE3EWwdDJlMhqmpKVRWViIhISHQy7KCL3f92WyPvr6+BectvLE2Lu6eWsJW96tWq6FUKjE2Nob29nZERUURKZVYLA4Pi3uAsETKDF8fB2dyKta8gpVTJSYmQiwWB2y33NJRy9vgYoCeK2Drk/C1Mh8mkwlRUVEOf56dnY3k5GTs3bsXN9xwAzo6OnDo0CEcPnwYjz32GHg8Hh566CG3XMNomsatt96Kc845x6nUaWRkBGlpaVb/lpaWhpGREZffyxGW1NOGywTDUhJlzyUqUGuPj4/Hd77zHXznO98BwzBoamoiZOPzzz9HR0cHOjo68NxzzyE6Otqqu+GtNbPHhqIon80YBAvB0Ov1mJqaQmJiotfkYd6GJ4PUrsBgMEAul2N2dtaleQtHaws2iZSroCgK8fHxiI+PR35+PoxGIyYnJ6FUKtHe3g6tVmslP/H3sHgYwQ1/B8vZyqkMBgPpbrS0tBCXHolEgsTERL+ez74YZmYYBk899RTuu+8+AMBll12G5557jpP3eHtgHaTC95T5cNWmlj2HS0pKUFJSghtvvBFGoxG1tbVu1z033XQTGhoacOLEicUsfVFYUgSDqxIpe5IoW3CBHFEUhZUrV2LlypW4/fbbMT09jU8++QT79+/HwYMHMTg4iP379xMdYE5ODrZv346LL74YW7ZsccrgHWFsbAx1dXVOj403EAwEY2RkBO3t7RAKhdiwYQNnb+S+kEixczexsbGorq5elFFDMEuk3IFAILAaFreUn/T09Fi5+YSHxR0jWL9/byPQnRyhUGhXTjUxMUHkVKyUytdyKm+TLdsAvV/84hd44IEHgkputJQdpBbCYnIwBAIBKisr3Xq/m2++Gf/+979x7NixBeXT6enpGB0dtfq30dFRKwWNpwhJghEsEilnkihbcG3tACASifDd734X3/3ud8EwDBobG4kz1cmTJ9Hf34/XXnsNr732GmJiYqy6GwsNq9E0TaQw5eXlyMjI8Oln4TLBYI9Ff38/8vPzMT4+zllyAXh/15+dt/DG3I0nLjihUmDaptKy8pO+vj4yLM7KqUQiEZn9CiMs+wACTzAs4UxONTg4iObmZsTGxhKy4W05lTfdkmwD9B599FHcfPPNXvnb/kQwRgD4Cwvlg7BZSO4GBNv7O7fccgs+/PBDfPrppy6ZAlRXV+PIkSO49dZbyb8dOnQI1dXVi1oLEKIEwxG41MFYSBJlCy4SDEtQFIXy8nKUl5fjf//3fzE1NYW//vWvOHPmDE6ePImhoSH897//xX//+18AZsvdPXv2YNeuXdiyZYvVbpNOp4NMJoNer0d1dbVf9KdcJRh6vR4ymQw6nQ5VVVXQarXzdhu4Bm8V5QzDoKOjAz09PVi9evU8nag/1saVgsrbsJWf6HQ60t2or68HTdNISkqCTqdbMDk+1BEqBHOx4LIFqeX5DJjllGz+gKWcylvyQG/t1k9PT+PKK6/E0aNHOR2g5wqWUsieu3ClgzE7O7voWuemm27CW2+9hf/7v/9DfHw8maNISEggEqurr74aWVlZ+O1vfwvA3C0777zz8OSTT+Kb3/wm/v73v+PMmTP405/+tKi1AEuMYHClSHdFEmULrqzdVSQkJGDnzp341re+heLiYtTX15Ph8JMnT6KtrQ1tbW14+umnERMTg23btmH37t3YtGkTVCoVkpKSsH79er8NpXKRYExNTUEqlUIsFqOiogICgQA6nY7zBY83ZjAMBgPq6uqg0Wi8SjKD3UXKV4iMjERGRgYyMjLAMAxmZmaI/KSjowNDQ0PEmSqQw7WBQqgSTXfApQ7GQhAKhUhNTUVqaqpV6BkrD2SzZDyVU3lDIhVMAXquICyRcgx3ZjAWgxdeeAEAsHXrVqt/f+WVV3DttdcCAPr6+qy+p5qaGrz11lu45557cNddd6GkpAQfffTRojMwgCVIMALZwXBHEmWLYCMYwNdJ3hRFYfXq1Vi9ejV++ctfYnJyEh9//DEOHDiAgwcPYnh4GPv27cO+ffsAAEVFRfjmN7+J3bt3Y/PmzX6xJmQJBlceov39/WhpaUFxcTHy8/PJmrhIhGyx2BkMtVqN2tpar8xb2CKUh7y9BYqiIBKJIBKJMDExgeTkZERFRUGlUqG1tRV6vZ4M13I5q8BbWGrfvyNw5d7oLmxDz9gsmcXIqRbbzbEN0Hvvvfewdu1aj/8eFxCWSDnGQgSDpmmHMxjuwJV71aeffjrv3y655BJccskli3pvewhJguHoJigQCALW7ndXEmULtlgPJjgiRWKxGBdddBEuuugiMAyD2tpavPHGGzh+/DhaWlrQ2dmJp59+Gk8//TRiY2NJd2PXrl3Iy8vzyVrZG2OgH6KsHe/Y2BgqKiogkUisfh4MBGMxRfno6Cjq6+uRm5uLkpISr38XYYmU++Dz+UhJSUFKSgrZDVYqlVCpVOjq6oJQKLTaDfYmIeQKwudB4O+N3oJllkxhYSGRU9kSaGdyqsXs1gdbgJ6rCHcwHGMhgjE7OwuGYRY9g8E1hCTBAOwXEnw+H1qt1u9r8UQSZQuBQBB0BIPH4y1I6GZmZqBWq3HVVVfh8ccfx+zsLI4cOYL9+/fj0KFDGBkZwb///W/8+9//BgCUlpaSQfFzzjnHa8437HcSyJvk3NwcpFIpseO157oVDDvqnsqQ2HmLVatWecXBwtl7WWKh9XL9ePsTlrvB7HDt5OQkVCoVent70djYCJFIRORU8fHxQV90hL9/M0KFYNjCEzmVpxKpYAzQcxXhGQz7YBhmwe7O7OwsAARF3ok7CFmCYQ/+lkgtRhJli1DqYADmi25gYAAtLS0oLCxEYWEhKIpCREQE9u7di71794KmadTV1RFnqlOnTqG5uRnNzc146qmnEBcXh23btmHXrl3YvXs3cnNzPV4re/GbTKaAhJEpFArI5XKkp6ejtLTU4c0oWDoY7qzRaDSirq4OarUaVVVVPt3FcVe+FQyELpCwLL4AkGFxpVKJwcFBMAyDxMREIqfyxKqaCwjFwtpdhCrBsISrcqrIyEiYTCaXtPUs3nrrLdx8880wGo3Yvn07/va3v4VUQRmWSNkH+yx0VldoNBrw+XzOJNV7C0uKYPizC7BYSZQtAj0/4gkcFcMmkwlNTU0YHx+3KwOyfP3atWuxdu1a3HHHHVCpVDhy5AgOHDiAQ4cOYXR0FP/617/wr3/9CwBQVlZGuhvuhtBZdjD8CYZh0N3djc7OTpSWli7oWR0MBMOdIl6tVkMqlSI6Otrr8xaOEJZI+Q72hsWVSiWGh4fR2tqKmJgYn1mHhuFbLAWCYQtHcqqBgQHMzc3h2LFjC4ZXBnuAnqsIS6Tsg605nR0btVqN2NjYkDt+IUswHEmk/FGke0MSZQs+nw+dTueF1fkP9joYGo0GMpkMfD7foQzIEZKSksgwEk3TkMlkxJnq9OnTaGpqQlNTE/7whz8gLi4O27dvJ4RjocKdoiifJVA7gtFoRH19PaamplBZWYmEhIQFX8Oe11x+2Lu668+GKObk5GDZsmV++TyevEe4g+EZLIfFCwoKrLTurHUoW5xJJBLExMRw8pzm8rXmT4SPw9dyKr1eDx6Ph2XLljmVUwmFQtx5553E3ScYA/RcRZhg2IcrBMMbDlJcRMgSDHvwdQfDm5IoWwSzixQLlnhlZ2dj2bJli7oZ8Xg8VFRUoKKiAnfeeSdUKhUOHz5MnKnGx8fxz3/+E//85z8BACtXriS5GzU1NXZ3yv3ZHWB37qOiotzqtnBlGN0ZXJlp6OzsRHd3t19CFN1Z22J/P9TgzXPMVuvOJjErlUqrYXGJRILExMSQHBYPZnD5nuNvsPMGzuRU9fX1eOaZZ3D06FEAwCOPPIJbbrklwCv3HdyRiy0lsMfF2bXjDQcpLmJJEQxfFunelkTZgs/nc14aYwt2zTRNo7W1FYODg14nXiySkpJw6aWX4tJLLwVN05BKpVbdjcbGRjQ2NuLJJ59EfHw8zj//fDK7kZWVZbVeX4NNps7Ly3PbKYkLw+gLwRlRY+ctZmZmfD5vYQ9hFyluwDaJ2WQyYWpqCkqlEt3d3VbD4myyeKC+i6VMMC0RJhhfw55NraWcKjk5GVdccQWOHz8OgUCA//mf/0F5eTmkUqnXwv64hvCQt324moHB1Q7uYrCkCIavkrx9IYmyRbDOYBgMBpw+fRpGoxHV1dV+Yek8Hg/r16/H+vXrcdddd0GpVJLuxqFDhzA+Po6PPvoIH330EQBg1apV2L17N1JTU70SLuMINE2jvb0d/f39HidTszcgLhc9jop4jUYDqVSKyMhIVFdXB0SDHA7acx/++Px8Pt9qWFyr1RLpSX9/PwCQn0skEr8NQ7KfPdQe/J4gTDC+hjMXqZGREVx88cWoq6sjAXpbt271etgf10DTdLjraAeuEAy1Wh2WSAUT7F383u5g+FISZYtg7GBoNBrMzs5CLBZj5cqVAdvdkEgkuOyyy3DZZZeBpmnU1taS7saXX36J+vp61NfXAwAeeugh7Nixg3Q3MjMzvbIGnU4HuVwOvV6/KKIVqGF0d2CviB8fH4dcLveKPM7ba/Pm74fhHURFRSEzMxOZmZlgGAbT09NQKpUYGhoiw+KsM5VYLPb5+RQurMMEwxKOOsiWAXopKSl4//33SYCeMzlVS0tL0BsghDsY9uEKwZidnQ1LpIIdlpKdxT6QfC2JskUwzWAwDIOuri50dnZCIBBg1apVnHkw8Xg8bNiwARs2bMDdd98NhUKBw4cPY//+/fjvf/+LqakpfPjhh/jwww8BAKtXr8auXbuwZ88eVFVVeWRhOzk5CZlMBrFYjIqKikXZ4LLHMVgIBnsudHV1YeXKlV4jbIuBJxKpcHEVOFAUhYSEBCQkJFg5+SiVSjQ3N8NgMCAxMZEUZ6EoNeACPM1+CEXYk0jZBuh98MEHKCwstPv6hcL+dDodCfuTSCRBIacK29TaR7iDsUTAFnaLvRD8IYmyRbAQDL1ej/r6eqjVapSXl6O5uZnTN8bk5GRcfvnluPzyy3H8+HFoNBp8+eWXOHjwIM6cOYO6ujrU1dXh97//PRISEnD++eeTVPGFhpMZhkF/fz9aW1tRXFyM/Pz8RR8L1u2Ky7vq7AyGpUvWpk2bIBKJAr00h8fOEYHg8rm7VGE7LK7RaKBSqaBQKNDZ2YmIiAirYfHFEPqwROprhEn217AlW4sN0LM8pwEQAwQ2wJLH41mRaC7myXB5LjCQcHUGI9zBCCI4kkgB5i/cE62gPyVRtggGgjE1NQWpVAqRSISamhrodDpO77TbQigUYs2aNdizZw9+85vfYHx8HIcOHcKBAwdw+PBhKJVKfPDBB/jggw8AAGvWrCE2uJs2bbIqZCyzPtavX0+05d4A17MwKIqCXq/HF198gYiICLczSXwJT8lZuLjiJiiKQlxcHOLi4pCbmwuTyUSSxTs7OzE3NweRSETkVPHx8eHv0QOw10y4gDTDct7AFwF6tnIqNk+GlQhGR0cTspGYmMgJaVJYImUfrkqkwh2MIAdFUR4PS/tbEmULLhMMy536oqIiFBQUgKIoGI1GmEymoCnObAv3lJQUfP/738f3v/99mEwmnDlzhtjgnjlzBnK5HHK5HI8//jjEYjGZ3diyZQuGh4dBUZTbWR+erJNr0Ol0GB4eRm5ubkDnLezBUxcpLneMfIlguG4twefzIZFIIJFIUFJSAq1WC6VSCZVKhb6+PlAU5dZg7VL93m0R7uRYg32mPfXUU7j33nsBAJdeeimef/55r2+m8Hi8eRJBlkS3tbVZyakCSaLDEin7cFUilZyc7KcV+Q9LimAAnhXqgZBE2YJdN9eKdaPRiMbGRqhUqnk79cGQ2WAJ29wOS/D5fGzatAmbNm3Cvffei7GxMavuhkqlwnvvvYf33nsPALBixQp85zvfAcMwqKysXJRMwxZclUixqeRKpRLJyclYsWJFoJc0D+6eh8Fw3obhGFFRUcjKykJWVpbVYO3AwACam5sRFxdH5FQJCQkO7+1L/TwIEwxrGI1GPP3003jzzTcBAD//+c/x4IMP+qU2EAqFSElJIRKs2dlZMr8RSDlVWCJlH650djQaDfLz8/2zID8iZAmGoxuhO1a1gZRE2YI9QbnUhlSr1ZDJZBAKhaiurp53I7OUpAXDjcedzkBqaiquvPJKXHnllTCZTDh9+jTeeecdHD58GB0dHWhpaUFLSwsef/xxJCYmku7Grl27PLKn9XSd/oLRaERDQwMmJyeRlpbGSY0wsDiJVBjBDdvBWr1eT4bFGxsbYTKZ5g2Lh793M8IE42vodDrce++9OHLkCADg0Ucfxc033xyw9bByKpZEz8zMQKVSYXh4eJ6cSiwWe3WzyxJcqk24hLCL1BKCqx2MQEuibGFZrHPhIh4eHkZDQwNyc3NRUlJil0Cw/+bpzIu/4WnhTtM0IiMj8b3vfQ8PPvgg5ubmrLobExMTePfdd/Huu+8CACoqKogNbmVlpdvfJ9cIxuzsLGpra8m8RVdXF2cLs7BEKgwWERERSEtLQ1paGhkWVyqVGB8fR3t7OyIjI5GYmAggeO5hvkKYYJgxPT2NK6+8EkePHoVAIMBLL72ESy65JNDLIrCUUxUUFMBoNJLuRnt7O7Rarc/kVMGykehvuHLv0Gg04RmMUIArMxhckETZwrJYDyQsuzpr1qwhrhf2wOPxQFEUp4phZ/CkcJ+ZmYFUKkVMTAwJjxOJRLjqqqtw1VVXwWg04ssvv8T+/ftx8OBBSKVS1NbWora2Fr/73e+QlJSE888/H3v27MHOnTudHk8WXJJIKRQKyOVyZGZmYvny5Zz/zsNJ3u6DK+eaL2E5LJ6XlweTyYSJiQkoFAoAwMmTJ4PONtSbCBMMYHR0FHv37kVdXR2io6PxzDPPcIpc2INAILCSU1mG/bEzSd6SU4UlUvbhqotUmGAEEZxJpBwV6VySRNmCHVAPJMGYm5uDTCYDwzAud3WczTVwDe4SDLaLk5+fj+LiYrvnnEAgQHV1Naqrq/HAAw9gZGQEBw8exMGDB8nsBtvdoCgKFRUVxJlqw4YNdm9MXOhgMAyDnp4edHR0oKysDFlZWeRnXCYYgHXB7GrBtBSK7DC+Bp/PR3JyMhISEjA0NISNGzdiamoKSqWS6NxZspGUlMQZlzRfYakTjPb2duzduxc9PT1ISUnBI488gi1btgR6WW4jOjraaibJm3KqsETKPsI2tUsIjop0rkmi7CGQBGN8fBx1dXVIS0tDaWmpyzeSYEogd7Vwp2kabW1tGBgYWLCLY4v09HRcffXVuPrqq2E0GnHq1CniTCWTyXD27FmcPXsWjz76KCQSCXbs2IHdu3dj586dZBcq0AW8yWRCQ0MDJiYmUFlZiYSEBKufc6nDYgt7a3NWNIUlUksb7PceHR2NuLg4UphNTU1BpVKhv78fTU1NiI+PJ4WZs2HxYMVSJhhnz57FxRdfDKVSiYKCAnz44YeYmJgI+u/Ym3IqhmHCHQwHWEg6xjAMZmdnER8f78dV+QdLkmDYSqRYSVRWVhaReXARgegGMAyDjo4O9PT0zNupdgVc2G13Fa4QOJ1OB5lMBoPBgOrq6kXtOggEApxzzjk455xz8OCDD2J4eNiqu6FUKvHOO+/gnXfeAUVRWL9+PXbv3o2srCzk5uZ6/L6LwezsLKRSKenM2LP55PF4nC3IwxKpMDyB5XnAuvQkJiaiqKgIer2eyE5sh8UlEgmio6MDuHLvIFicAL2NQ4cO4Qc/+MG8AL0vv/ySs3WCp1hITgXAyuLZUk7FPuND7Zh4AyaTacFOUFgiFWRwRSLFZUmUPTiTd/kCer0ecrkcc3NzqKqq8ohhB1rW5Q54PB4MBoPDn09OTkIqlSIpKQnr16/3uhtHRkYGrrnmGlxzzTUwGo344osvcODAARw4cAB1dXU4c+YMzpw5AwBITEwkUqqdO3f6xUNbqVRCJpMhIyPD6WxSsHUwXAFXP08YvoUr33tERATS09ORnp4OhmGgVquhVCoxNjaG9vZ2REVFESkVV0LR3MVSJBhvv/02brrpJrsBerZJ3qEId+RU7EZbmGDMhyvD72GCESJgC95gkETZwp8djImJCcjlciQkJKCmpsbjYjqYOhiO1moZJFhSUoK8vDyfP1wEAgE2b96MzZs346GHHsLQ0BAOHjxI5FQTExP4+9//jr///e+gKAobN24kzlTr16/36o2eYRj09vaivb0dpaWlyM7Odvr7gZZwOYOnORhLlWCEehHlKlw9DhRFIT4+HvHx8cjPz7crOxGLxaQwC5Zh8aVEMBiGwR//+EenAXoMwyypYtoVORUA9Pf3QyKRBCzsj4tYaAaDpumwTW0wwt5upUAgwOTkJD7//HPOS6Js4Y9uAFtMtrW1YdmyZYsupoOtg2FbGJtMJjQ2NkKhUMwLEvQnMjMzce211+Laa6/FqVOnMDAwAKlUigMHDqC+vh6nT5/G6dOn8fDDDyMlJcVqdkMikXj8vuy8hUqlwsaNGyEWixd8TbB1MBY6v8MPyjA8ha3sZHZ2lshOenp6wOfzrWQnXB0WXwo79oD5c9511114/vnnATgO0Fsqx8MRbM9rlUoFmUwGtVqN/v5+AF/LqRITE0NCJugpFiIYGo0GAMIzGMEOmqahUCgwOTmJNWvWcF4SZQtfF+tsWNrExAQ2btxIPOAXg2B2kWK7XDweDzU1NZwJj4uIiMD69euxd+9ePPzwwxgcHCTdjSNHjmB8fBxvv/023n77bfB4PNLd2LNnD9atW+cyoZ6bm4NUKiWf3968hT2E0gyGp68JIzTg7eFmNhQtOzubDIsrlUr09fWRYXFWTiUSiTiz+bUUOhg6nQ7XXXcdPvjgAwDOA/TCA83WiIiIAJ/Px6pVq8AwDKanpwMS9sdFuEowwh2MIAZbLBoMBiQkJAQduQB8SzDYPIfo6Gi3ismFEKwuUqxr1kLzBoGAbcGblZWFH/7wh/jhD38Ig8GAkydPktmNhoYGnDp1CqdOncJDDz2E1NRU7NixA3v27MGOHTscdmTYeYv09HSUlpa69fm5XJDbk2+5slaufp4wfAtffu+Ww+KAucBluxv19fVgGMYqoyCQu8ChTjCmp6dx1VVX4dNPP4VQKMQLL7yASy+91OHvhwmGNSwtaimKWlBOJRKJiAlCKMupaJoGwzALEgyhUOi1motLCGmCwRY6li5RIpGItPCCDb4q1gcHB9HU1OQ0z8FTBFsHw2QyobOzE11dXVi5ciUyMzMDvax5cDbXIhQKce655+Lcc8/FI488gv7+fuJMdeTIEYyNjeGtt97CW2+9BR6Ph8rKSjIsvnbtWlAUReYtVqxYgZycHLfXx2WCAbhfNIbqwy8M1+Cv7z8yMhIZGRnIyMgAwzBkqHZkZARtbW1kF1gikUAsFvt1WDyUCYZlgF5cXBz+9re/Yfv27U5fs9RmMBaCs0FmZ+5UbC3GFSLtbbC1j7NrVa1WIzY2NiSvr5AmGCaTCc3NzVYuUWNjYwsmeXMVrqSQuwOTyYSWlhaMjIxg7dq15AbgTQRTB4N9qGu1WmzatAkikSjQS7ILdwbnc3Jy8OMf/xg//vGPodfr8fnnnxM5VWNjI7744gt88cUXeOCBB5CamoqNGzdi1apVuPbaaz0iF+6uz9+wJT9s545hGEgkErvFG9cJk68R/uz+B0VREIlEEIlEVsPiSqUSra2t0Ov1SEhIIHIqXxcooUowOjo6cNFFF5EAvffeew/r1q1b8HVLfQbDFu50dCzdqdhnrlKptCLSLOFITEwMajmVKwQjVEP2gBAnGFKpFFqt1solyt9Wr96EN4t1VjJGURRqamp8tmsQLB2MmZkZtLe3AzC7igmFwgCvyDE8LeAjIiKwdetWbN26FY8++ij6+vpId+Pjjz/G2NgY9u3bh3379uHxxx/Hpk2bSHdjzZo1Lj9AuFyQW65tbGwMcrkcOTk5iI2NxcTEBFpaWmAwGKxyDIClXWQvdXChkLTcBWYYBnNzc1AqlVCpVOjq6oJQKLQaFvf2/SsUd+ztBegVFhYu+DqGYULyeCwGnqZ4WxJpVk41OTkJlUqFzs5OzM3NETkVO5fEhevRVbCdHWdrZi1qg+lzuYqQJhilpaWIjIy0uhEEk6uRLfh8PnQ63aL/ztjYGOrq6pCZmenz+YJg6GAMDw+joaEBqampmJ6e5jS5ALxXwOfm5uInP/kJLrroInz55ZcYGhpCa2srDhw4gObmZpw8eRInT57E/fffj/T0dOzcuRO7d+/G+eef79QAgOsEg6ZpIoNbtWoVJBIJTCYT0tLSSKqqUqmEQqFAR0cHcVbLyMjwuzQljDBsQVEUGRbPyckBTdOkKOvp6bFKFmc17ou9x4daB8NRgJ4rYO9tYYLxNVzJenAFAoEAycnJJNdpbm6OzG8Eo5xqoQFvwEwwgiEmwROENMGIi4ubRya8LTPyJxZLjmiaRkdHB3p7e/02X8DlDgZN02htbcXg4CDWrFkDPp+PhoaGQC9rQXjrmDIMg76+PrS1taG0tBS7d+8GAPzud79Db28vkVJ98sknGBkZwRtvvIE33ngDfD6fdDf27NmD1atXz0s65irBYBgGExMTmJiYIDI4y3BFiqIQGxuL2NhY5Obmwmg04vPPPwfDMESaIhaLiZwqOjo6pAqvMKwRDIU1j8cjBVdxcTEZFlcqlRgYGADgOIHZVQTDcXAVlgF627Ztw9/+9je3LELZDbNQOR7egK+G3qOjoxEdHY3MzEyruaTR0VG0tbUhKirKyg6Xa3IqVwlGKIbsASFOMOxBIBCQyf5gu0EshmDodDrI5XLodDpUV1f77YTm8/nQ6/V+eS93oNPpIJPJYDQaiYRuYmKC890WwDtBdiaTCU1NTVAoFNiwYcO8jkReXh5++tOf4qc//Sl0Oh0+++wz4kzV0tKCzz//HJ9//jnuu+8+ZGRkYOfOndizZw+2b9/O2aC9ubk5DAwMgKZpbN68mbh2OLsPCAQC8Hg85ObmQiQSke6GUqlEZ2cnIiIiCNkI1pRmZwi2e2QY9ofFlUolsQyNiYmxsgx15ZwNxuelLRiGwdNPP43f/OY3AOwH6LkC9t4W7mB8DU8lUu7A3lySMzmVNzp3i4UrxyUUZzAYhsHOnTuXJsEAzAUW19juQvCUYKhUKsjlciQmJqKiosKvn5uLHYyJiQnIZDIkJSWhvLyc3AC4PJxsicV2CLRaLaRSKQCgurp6wR3NyMhIbN++Hdu3b8djjz2Gnp4eq+7G8PAwXn/9dbz++uvg8/nYsGEDysvLIRKJsGrVKk4UJhMTE8SGOSoqyi1LQHb9tt0Nk8lEBm/b2tqg0+msuhsxMTGc+OxheA6uduJcha3G3WAwEMkJO2/EnrNJSUkOz9lgJxi2AXq33HILHnroIY8K0LBEaj4CYdsbDHIqVzsYoUYwKIrCK6+8EtoEw94Nkf2yjUZjyBMMhmHQ09ODjo4OLFu2DLm5uX5/SHBpBsNSEmTveAQTwfB0nWyhnZKSgpUrV3r0UMjPz8fPfvYz/OxnP4NOp8Px48cJ4WhtbSW5Gy+//DIyMzOxa9cu7N69G9u3b0dCQoJH614MBgYG0NzcjGXLlhG9ujtwNFPC5/OtHnCW3Y2uri5EREQQHTwX2/dhuIZgLqxtIRQKkZqaitTUVDJvxMqpOjs7ybA4e86y82jBTDB0Oh2uv/56vP/++wCARx55BLfccovHf491kArW4+ELeGsGYzHgopzKFYKhVqtDUiKVk5MT2gTDHiiKAo/HC8o5DHcIhsFgQH19Paanp7Fx40aIxWLfLs4BuNLBMJlMaGxshFKptCsJArhFhpzBkyFqhmHQ39+P1tZWLF++HDk5OV55QEZGRmLHjh3YsWMHHn/8cXR3d+Ojjz7CRx99hLq6OgwNDeHVV1/Fq6++CoFAgOrqauJMVV5e7tOHNDtjMzQ0hIqKCkgkEvT09Mw7dq6swZXjbTl4azKZMDk5CaVSiY6ODmi1WojFYlK8harveagh2DsYzmDZkbM8Z1UqFbq7u9HY2EgkJ8EKdwP0XEHYonY+/CGRcgdckVO5QjBmZ2dDroPBYskRDCB4rWpdJRjT09OQyWSIiYlBTU2N2xpTb4ILRfvs7CykUikpcB1JgljpEdd369ztYNA0jaamJoyNjWH9+vU+LRgKCgrwwx/+EGvXrkV1dTXpbuzfvx/t7e04fvw4jh8/jnvuuQdZWVlW3Q1v5o4YDAbIZDIyc8S6dHhCzjx5DZ/PJ1IpAFY7xd3d3RAKhUSWkpSUFO5ucBhcvhd4E7bnrFarJYFoCoUCDMOgoaGBkGSuJw+Pjo7i4osvhlwudzlAzxWELWrng+vJ5rZyKstz25dyKlclUmlpaV55P64hpJ9qjh4MwWpV68q6WTlIQUEBioqKAv5wDHQHY3x8HHK5HFlZWVi+fLnTmyD7M67txtjCHYLBzlswDIPq6mq/6FDZgjwqKgo7d+7Ezp078cQTT6Crq4uQjaNHj2JwcBCvvPKKWaspEKCmpoY4U5WVlXl87qrVatTW1iIuLg5VVVVWxbunBGOxYLsb2dnZMJlMmJqaIlKqxsZGq9A0rnmih/Iu/kJYyp89KioKmZmZyMzMxMDAAIaHhxETE4OhoSG0tLQgNjaWnLNisZhTBaanAXquINzBmA+TycR5e3dLWJ7bvpRTuSIdC7tIhRiC1arWGcFgXYHGxsawbt06wtQDjUB1MBiGQWdnJ7q7u1225A0WguFqkcwOs0skEqxcudJvn8nR+goLC3H99dfj+uuvx9zcHE6cOIH9+/fjwIED6OjowLFjx3Ds2DHcfffdyMrKImRj27ZtLttIshkvubm5KCkpmVcIOFqbs+Pp7VwPPp9PHl4lJSWYm5sj3Y2enh6rnWRLHXwYgUG4mDQjIiIChYWFKCwshMFgIDvAzc3N88IpA2nf7GmAnqvg+m59IBDMx8SXcipXzITCEqkQQ6hJpDQaDWQyGfh8Ps455xyPfM59hUAMThsMBtTV1UGj0aCqqsrl4tSSYHAZrhzT/v5+tLS0BGS435X1RUdHk+7Gk08+ic7OTmKDy3Y3/vrXv+Kvf/0rhEKhVXejtLR03udhGAbd3d3o7OxEeXk5MjIy7L6vI4echeDLnezo6GhkZWUhKyvLKjTNUgfPEg6udTdCHUu5g2EJW9moUChEWloaCafUaDRESsXaNwfC4ODw4cP4wQ9+AI1Gg3Xr1uHdd99FamqqV98jLJGaD65vyrkDZ3KqgYEBMAzjspzKlc5OqA55AyFOMEJNIsXOCFjuFoyOjqK+vt4lCVAg4O9jPTMzA6lUitjYWFRXV7u1+8ueL8FMMGiaRnNzM0ZGRshgs7/hyY5/UVERbrzxRtx4442Ym5vDsWPHCOHo7OzE0aNHcfToUdx1113Izs626m5ER0ejoaEBExMTqKysdOpUFSiJlKuwDU3TarVQKpVQqVTo7e0l3Q9WmhLubvgeYULn3EWKoijExcUhLi6O2DezBgeWO8DsORsfH++TY7rYAD1XEcy79b4CF1ykfAV35FRisdjqnmwymRbc8NVoND45T7mAkCYYjiAQCIJSImWZ4QEAbW1t6O/vx6pVq5Cenh7IpTmEPzsYQ0NDaGxs9Hj+hHUY4zrBcFQka7VayGQy0DSNmpqagPh+A4uXFEVHRxOnKcCsp7bsbgwMDODll1/Gyy+/DKFQiPLyclRVVeHaa69dcFDcX0Pe3kJUVJRVd4Od3ejt7UVTUxNp3UskEp8UbuHiOgzAPZta22FxVgLIkmRLEp2UlLToYXHbAL1LLrkEL7zwgs/MTcIzGPOxVEiXq3KqxMRESCQSGI1Gl4a8WROSUMOSJBjB3MEAzJo9NiTJn6ncnsAfx9rSjnTt2rVISUnx+G8FA8Gwt8bJyUlIpVK/z1vYA1uQe8uNq7i4GMXFxbjpppswOztLuhv/+c9/0NvbC6lUCqlUihdeeAG5ubmEnGzdunXeteEpWeCCVIbH4yExMZFYLOt0OpK70dfXRwo3dqc4kO5xoQKuO8r5C4s5DrYSwOnpaSI3aW5uRlxcHDlvExIS3CpUaZrG3Xffjeeeew7A4gL0XEVYIjUfS4Vg2MKZnGpwcBAGgwE6nQ4URZEgS0uwWTThDkYQwtENMVg7GOwFfObMGaSkpGD9+vWct7dki2FfPai1Wi3kcjmMRqOVHamnCEaCwT6oS0pKkJeXF/CCiH1/X3znMTEx2LNnD1atWoULLrgAQqEQDQ0NOHDgAI4fP46+vj78+c9/xp///GdERERg8+bNhHAsX76c8xIpdxAZGUla92zhxpIN2+6GSCTi7OfgMrhALLkAb13LPB4PYrEYYrEYhYWF0Ov1mJiYgFKpRGNjI0wmk5W+3dn93NsBeq4i3MGYj1CawVgMbOVUp0+fRkxMDMbGxtDe3o7IyEiMjIxAo9HgggsugEQi8YqL1LFjx/DEE0/g7NmzGB4exocffogLL7zQ4e9/+umn2LZt27x/Hx4e9qoahtvVqY8QjB0MhmHQ1dUFAMjNzUVxcXFQ3OTYm44vbkC+cEkKBoLBFsk0TaOlpQXDw8MBm7ewB5YI+6I4YxgGra2tGBwcREVFBZKTk7Ft2zbccsst0Gg0pLuxf/9+9PT04OOPP8bHH3+MX//618jLy8OWLVuwYsUKrF692mXnjkBKpFyFZeFWVFQEnU5HnKkGBgbIDlq4uxGGJ/DVBlFERMS8YXGlUonx8XG0t7c7tAu1DNATCAR44YUXcNlll3l9ffawVHfrnSGUZzA8BXu9pKenIzk5mcwm1dbW4qWXXsItt9yCFStWYHJyEq2trVi3bp3HM3UajQZr1qzBj370I1x00UUuv661tdVKVuxtQ4SQJxj2igM+nw+dThegFbkPvV6P+vp6qNVqCIVCJCcnBwW5AL4uNl0JnHEVDMOgr68PbW1tXndJCnRuhytg1/jll196rXPjTVh2MLwJg8EAuVyOubk5VFVVzSMIsbGxuOCCC3DBBReAYRi0t7cTsnH8+HH09vait7cXAPDggw9iy5Yt2L17N3bu3Im8vDyn7811gmGLyMhIZGRkICMjAzRNY2ZmBkqlEv39/WhqakJ8fDzRyYe7G44RlkiZ4Q9ZkOWweF5eHkwmEyYmJqBSqdDR0QGtVouEhATQNI2f//znaGhoQFxcHN544w2cf/75Pl2bJcISqfkIky77sKx72Nmkm2++GTfffDO6urrw73//G/fccw9uvfVW3Hzzzdi+fTt27tyJXbt2uTVHyj733EVqairEYrHbr3MVIU8w7CGYbGqnpqYgk8kQFxeHmpoanDx5kvM77Jaw7GB4A0ajEY2NjVCpVNiwYQPRo3sLwdDB0Gg00Ov1kEgkKC8v51xr2hduXGx4XmxsLKqqqhbc6aEoCsuWLcOyZctId+PTTz/FRx99hEOHDmFkZARHjhzBkSNHAAB5eXnkxn7uuedaEbZg6GA4A4/HQ0JCAhISEogshXWmksvlAGDV3bAdug3mz+4NhAlGYIgWn8+30rfPzc2htrYWP/rRjzA8PIyEhAQ89dRTWLlyJfR6vd+6cuFiej7CEin7cLaxWlhYiKuvvhr33HMPWltb0dfXh4MHD+L999/HbbfdhqysLOzcuRMPPPCAz0x81q5dC51Oh/Lyctx///0455xzvPr3lyTBCAaJFMMw6O/vR2trK4qKilBQUACKooJi7ZagKAoURXllzRqNBlKplOQiLNZ9xB64TjAGBgbQ1NQEHo+H1atXc7L48bZEik1jz8nJwbJlyzz6zLGxsfjmN7+JyspKXH311UhJSSHOVCdOnEBvby/+8pe/4C9/+QsiIyNxzjnnYNeuXdi5c6dXPgOXEBERQbobDMOQ2Y3BwUEydMt2N5Y6uQjDDC50cpqamvCDH/wACoUCBQUFePXVVyESiay6cqycyt1hcXcQnsGYj7BEyj4WUm5oNBoAgEgkQkVFBSoqKnDHHXcQue/Bgwd9YuKTkZGBF198ERs2bIBOp8Nf/vIXbN26FadOnUJFRYXX3ifkCYYjiRSXh7yNRiOampqgUCjmaeuDjWAA3knzZhOafZ33Eajk8YVgOW9RVlaGpqYmzj7kvCWRYhgGPT096OjocDmN3dW1rVixAitWrMAvfvELTE9P49ChQ/j4449x6NAh9PX1kdmNO+64A5mZmdi2bRsuvPBCbNmyhVNytMWCoqh53Q12dqO+vh5GoxGzs7MQCoWQSCQ+IfVcBhcKay4g0LIgywC9tWvX4r333iN68aKiInLeqlQqNDQ0gKZpYhW6UBiauwh3MOYjfEzmg52TXIhgREZGzjPrsZT7+gLLly/H8uXLyX/X1NSgs7MTf/jDH/DGG2947X1CnmDYA5clUmq1GjKZjOzS24a0BCPBWExXgGEYdHR0oKenx2tFpjNwsYOh0+kgk8nIvAXA7TBAbxAMk8mExsZGKJXKBcPz3F2b7bri4uLwjW98A9/+9rfJEPmhQ4dw6NAhfPbZZxgaGsKbb76JN998E1FRUdi8eTNJIS8uLvbKuriCiIgIpKenIz09HQzDQCaTATBnzLS2tiI2NtZjS9EwgheBJFp///vfceONNzoN0LM9b9VqNZRKpVUYGks2EhMTFyXnCZNOa7CW5GGJlDXYZ/RCBCM2NpYT51NlZSVOnDjh1b+5JAkGV4v04eFhNDQ0IDc3FyUlJXYf3lxduzN4uma9Xo+6ujrMzs6iqqrKL17RXCMYU1NTkEqlEIvFxJZYq9UC4PaDbjFzC1qtFlKpFABQXV29YBKqN9bFHkeKokh345ZbbsHMzAxee+01yOVyfPbZZxgYGMDhw4dx+PBh/PrXv0ZhYSEhG1u2bAlYuKEvQFEUhEIh4uPjkZeXB4PBQLob7C4xK0mRSCRe/Z64grBEzIxAyIIYhsEzzzyDe+65B4DrAXoURSE+Ph7x8fEkDI0dFm9ra4NOp4NYLCbnrbsFXni33hrssz18TKzBHhdnBEOtVrvsZuhryGQyZGRkePVvhjzBsHfj4FoOBhsUNzg4iNWrVyMtLc3h7wYjwfDEmWl6ehpSqRRxcXGorq722L7NXXCJYAwODqKpqclqBgf4+kbO5cE6T4/j1NQUamtrfRYY6C7xiY+Px5YtW3DhhRciKysLLS0tOHToEA4ePIiTJ0+iq6sLL730El566SVERUVhy5YthHAUFRV5de2BgOX9UygUWlmKsrvEIyMjaGtrQ0xMDNklFovFIVNwcJXE+xP+3sywDdC7+eab8fDDD3t0TgkEAqSkpJAA1tnZWSKn6unpAZ/Pt0oWX4jAhAmGNdj7fPiYWMNkMpEZVEdgMzAWe22p1Wp0dHSQ/+7u7oZMJkNSUhJyc3Nx5513YnBwEK+//joA4KmnnkJBQQFWrlwJrVaLv/zlL/j4449x8ODBRa3DFiFPMOyBS0X63NwcZDIZaJpGTU3NgvpuLq3dVbg718AW1oWFhSgsLPTrg40LBGOhZPJgIBiedDCGhobQ2NiI4uJi5Ofn++x79yRojy2wSktLUVpaip///OeYmZnB0aNHcfDgQRw6dAiDg4NEWgWYteGsM9XmzZuDdoffUcfHcpfYYDCQwLSmpiYSmOYLDbw/Ee5gmOFPgqHT6XDDDTfgvffeA+D9AL2YmBjExMQgOzsbNE1jamrKKqCStXBOSkqCSCSaVziH5UDWCBMM+2AHvBciGN6Y6Ttz5oxVcN7tt98OALjmmmvw6quvYnh4GH19feTner0e//M//4PBwUHExMRg9erVOHz4sN3wvcVgSRIMdgYj0BIThUIBuVyOtLQ0lJaWunTTCkaC4WoHw3KQ2V5h7Q8EmmDo9XrIZDLo9XqH+Ra+ypnwJtwhGAzDoK2tDf39/T7/3j253h29Jj4+Ht/61rfwrW99CwzDoLm5mZCNkydPorOzE52dnXjxxRcRHR2NLVu2EGeqgoKCxX4UTkEoFCI1NRWpqal2NfDR0dHEmSrYuhvhDob/CIa/A/R4PB4SExOJ3TkbUKlSqVBfXw+GYaySxaOjo8MuUjZgHaTCx8QarmR/eSPFGwC2bt3q9Hn76quvWv33r371K/zqV79a9PsuhJAnGPZOevZLN5lM86b3/QGGYdDZ2Ynu7m6UlpYiOzvb5dfy+XwYDAYfrs77cKWDodVqSScnkMFxgSQY09PTqK2tRUJCAioqKhyem5YdDK6Cx+O5RDAMBoPVnI0vLPksQVGUR8dtoc9CURTKyspQVlaGW2+9FdPT0/j0009JR2NoaAgHDx4kLeji4mJCNs4555yg7W7Ygz0NPDu70dzcDIPBQLobEomE090NLpN4f8IfBGNsbAx79+6FXC5HbGws/va3v/k1QA+wDqhkGAYzMzNQqVREBsieqyKRyKvhscGMsGTMPlwlGFyZwfAFQp5g2AP7pRuNRr8TDMvB5U2bNlnFtLsCPp9PhnyDBQt1MFQqFWQyGVJSUlBWVhbQm3agCAYrD3JFFsbqOrlMMFxZn0ajQW1tLaKjo10Kz/PWujx5jbuFpkgkwne+8x185zvfAcMwaGxsJGTj5MmT6OjoQEdHB55//nnExMRYdTfy8/PdXiOXIRAIrLobGo0GSqUSY2NjaG9vR3R0NBm4FYvFnCvawjuzvicYHR0duOiii9DT04Pk5GS89957XvXj9wQURUEkEkEkElkNi7e3t0OhUGBsbAwJCQlETsUVNyB/I0ww7CNMMJYoweDxeB4NHi8Wk5OTkMlkSEhI8HhwORglUo46GAzDoLe3F+3t7Vi+fDlycnICfoP293lB0zTa2towMDDgljyI6+nSC62PlQeyuSb++t49OW6LPdYURaG8vBzl5eW47bbbMDU1RbobBw8exMjICAn9A4CSkhKr7kYoZU9QFIW4uDjExcUhLy+PFG1KpRItLS2ku8ESjkBnjnD5GvMnfEkwamtrcfHFF0OhUCA/Px8ffvghJw0S2GHx4eFhiMViSCQSIqfq6uqCUCi0Ghb3lzFJoBHu5NiHK+GD3pJIcRUhTzAc3RT9WagzDIO+vj60tbUteoA1EMRosbC3ZqPRiMbGRqhUKmzcuBFisTgwi7MBj8fzmwRNr9dDLpdDp9OhurrarZ2MQM+KLARHRbklqSwrK0NWVhYn1uVPJCQk4Lvf/S6++93vgmEYNDQ0ELJx6tQptLe3o729Hc899xxiY2Nx7rnnEmeqvLy8gK7d27B0+GEYBrOzs1AqlVAoFOjo6PBqfoGnCPSmBxfgK4Jx5MgRXHXVVXYD9LgK1lwjNjYWsbGxyMnJgclkwtTUFHGmskwWl0gkEIlEIXsehTsY9hHuYCwBguEI/rKqNRqNaGhowMTEBDZs2ECGyTwFl0MCHcG2g6HRaCCVSkmYIJd2aP1VuLM2vCKRCOvWrXNbqsd1iZS940jTNBobG6FQKAJGKgPRwVjob69atQqrVq3C7bffjsnJSXz66ac4ePAgDh8+jJGREfz3v//Ff//7XwDmBFaWbHDt2lksKIoiRVtubi6MRiMmJyehVCrR1tYGvV5Pdo6TkpIQExPj86It0GSUK/BFkrcrAXpchL1jYWl1W1xcDJ1OB6VSCZVKhYGBAQCw6m6E0sxVmGDYh6sEw9+bbP7EkiUY/uhgzMzMQCaTITIy0mvFQLB3MMbGxlBXV4fs7GwsW7aMczcmfxxfNlBxMTa8rg5RBwq2RblOp4NUKgXDMF4Pz1vMunz1Gk8hFotx4YUX4sILLwTDMKivryfOVKdPn0ZraytaW1vx7LPPIjY2Fueddx4hHLm5uX5Zo78gEAiQnJyM5ORk0t1gh8U7OzsRERFBBsV92d0I1Z1nd+DtDsbTTz9NAvQuvvhivPjiiwvmT3AFrrhIRUZGIjMzE5mZmWRYXKlUYnh4GK2trYiJiSFkg4tzR+6Ay3bpgUS4g7HECYYvOxjs0G5eXh5KSkq8dnMO1hkMvV6P9vZ29PT0oLy83OuJkd6CLzsYlnasa9asWZQUIJgkUmwaeWJiIsrLywP+MOIyMbMERVFYvXo1Vq9ejf/93//FxMQEPvnkExw6dAiHDx/G6Ogo/vOf/+A///kPAGDFihUkd6O6utorBRtXimvL7gYrSWHTmdvb26HVakl3g53d8Mbag+Vc8TW8RTC8GaAXKLi7Y285LF5QUGCVGcPOHfm7M+dNuDJrsBThCsGYnZ0Niq6dpwh5guHoQvWV1IimaTQ3N2NkZGTRRaQ9BCPBYBgG4+Pj4PP5qKqq4vQF5avCnZ230Gq1XrFj5bpEiiUYbLfGNo08kOsC3CuYuDC3AQCJiYm46KKLcNFFF4GmadTV1RFnqtOnT6OlpQUtLS145plnEBcXh/POO48Mi7tjhW0LLnx2W/D5fNLdAEBmN9iB24iICKJ/T0xMDIgdeSjBGwRDr9fj+uuv91mAnr+wWLmYbWaMbWdOKBRazR1xfVg8LJGyD1cIhlqtDncwQhG+6GDMzs5CJpMBgM+yHIKNYExPT2NgYAA8Hs9j5yx/wt3UcVcwMzOD2tpaxMfHo7q62ivFTjBIpIaGhqBSqQIWmmgP/rKp9TV4PB7Wrl2LtWvX4pe//CVUKhXpbhw6dAjj4+PYt28f9u3bBwAoLS0lZKOqqipo5Ciugk1nZrsb7OxGZ2cn5ubmiJ2oRCJxy0400GGsXMFij8PMzAyuuuoqfPLJJxAIBHj++edx+eWXe3GF/oM3g/bsdeYmJyehUqnQ3d2NxsZGiEQiQpbj4+M5dz6GJVL2YTKZFrzPzs7Ohl2kQhHe7mCMjY2hvr4e6enpKC0t9Rmj90UB7CsMDg6iqakJSUlJYBiG8+QC8H4HY2RkBPX19SgoKEBRUZHXHg5clkgZjUZoNBq/hee5A087GFxHUlIS9u7di71794KmacjlckI2vvzySzQ3N6O5uRl//OMfER8fj61bt5LZjVAbMuTz+YRMAMDc3ByUSiWUSiW6u7uJnSi7SxzubiyMxRCMsbExXHzxxZDJZAEL0PMmfLljb3vuarVaYoXb398PAFbnLhdMHsISKfsIz2AsAYLha5tahmHQ3t6O3t5erFy5EpmZmYv+m87ArpvLO2uWMrF169ZBq9VieHg40MtyCd4q3Nnzoq+vzydSOS7uqgPmHZna2loAQFFREafIBWBNMNwBF4+1I/B4PKxbtw7r1q3Dr371K6hUKnz88ceEcCgUCvzrX//Cv/71LwDAypUrCdnwV+ChPxEdHY3s7GxkZ2cTO1GlUomuri40NjYiISGBFG1xcXHz7qtcvc/6E54+bzo7O/G9732PUwF6i4UvHLUcISoqigyL0zRNhsUHBwfR3NyM2NhYQjbEYnFACv2wRMo+FiIYbOgolyXji0XIEwxH8IZESqfTkRwDf80WsCcsV9uSWq2WuAXV1NQgOjoaQ0NDQSPr8gbBMBgMkMvlPt3B52IHQ6lUQiaTITMzE2q1mpOFmScEg6tkzlUkJSXh4osvxsUXXwyapiGTyYgz1ZkzZ9DY2IjGxkY89dRTEIlEVt2NUIOlnWhJSQnm5uaI/r23t9dqBzkxMZHTGzn+hCfHIVgC9NxFoApqHo+HhIQEJCQkoLCwEAaDgXQ3mpqaYDQarUIqo6Oj/XLucrUWCTTCHYwlQjDsFQgCgQBzc3Me/82JiQnIZDIkJiaioqLCb2129oTlYnqmSqWCTCZDSkoKysrKyPqCSda12MJ9ZmYGUqkUsbGxPp054RLBsAySLC0tRXZ2NmprazlZlC9FgmEJHo+HiooKVFRU4I477oBSqcTHH39McjeUSiX++c9/4p///CcAoLi4GFu2bMGll16KysrKkOxuZGVlISsrCzRNz9O/s3bKMzMzdrsbSwXuzh0EY4Ceq/DmDMZiIBQKkZaWhrS0NLIbrlKpoFAoiI2zP4wOTCZTWGZoB64Qr3CSd4jC0w4GwzDo6elBR0cHli1bhtzcXL/ebNidEy51BCyPyYoVK5CdnW11TLhUDC+ExayVnbfIz89HcXGxT88LrrhI0TSNpqYmjI2NWQVJcrUoXwoSKXcgkUhwySWX4JJLLgFN05BKpaS7cfbsWXR0dKCjowOvvPIKRCIRtm3bhl27dmHHjh2ctZr2FDwezyosTavVoqOjA5OTk6itrSXdD1aSEmpkyxnc6WC88847uOGGG4IuQM9V+FMi5SooikJcXBzi4uKQm5tr1+hAJBKRc9ebw+JhiZR9LLQJbDAYoNfrQ+rasMWSkGwPMQABAABJREFUJRieDHkbDAY0NDRgamoqoEnEXHKSYpPKJycnHR4TLq13IXhCMBiGQUdHB3p6erB69WqkpaX5aHVfgwsuUjqdDjKZDCaTCdXV1YiOjiY/CyWCwdXP4m3weDysX78e69evx5133gmlUonXXnsNp0+fxqlTp6BUKvF///d/+L//+z8AwKpVq4gzVWVlZcjtYkZFRUEsFoOmaZSXl5PZjd7eXjQ1NSE+Pp7Iqbjo7uNNuEownnnmGdx9990Agi9AzxUwDMOZDoYz2DM6YOVUvb29VmR6scPiYYmUfSxEMNRqNQCEOxjBDnsFgrtF7/T0NGQyGaKjo1FTUxPQmyZXCnaNRgOpVIqIiAhUV1c7vEmFcgfDYDCgrq4OGo0G1dXVfrtZBPqYTk9Po7a2FmKxGKtWrZp3I+VKh8UR3CUYSxESiQQXXHABvve97yE3Nxe1tbVkULy2thb19fWor6/Hk08+iYSEBGzfvh07d+7Ejh07kJ6eHujlewXsecLj8ZCYmEg6dDqdjjhT9ff3g6Ioq+5GKBXVwMIEg6Zp3HPPPXj22WcBADfddBMeeeSRkNvZtjwfggm2UsDp6WmoVCoMDAygubkZcXFx5PxNSEhw6/OFOxj2sRDB0Gg0ABCewQhFCAQClyVS7EXobatRT8EFgjE6Oor6+nrk5OSgpKTE6Q2GC+t1Fe4U7mq1GrW1tT6ft7CHQBbwrBSssLAQhYWFdq8Hru76e3rtcvGz+AsMw4DP52Pjxo3YuHEj7rrrLigUChw+fJikik9MTODDDz/Ehx9+CABYs2YNGRTfuHFjUHc37J0zkZGRVu4+09PTUCqV6OvrQ1NTk1V2gUgkCvgzY7FwRjBCJUDPFQQrwbAEj8eDWCyGWCxGYWEh9Ho96W40NjbCZDKRYXE2WdwZwja188EwjEsEIzo6OqS7P8F7118kXCl6TSYTmpubMTo6yqmwsEAW7Ja2vKtWrXJpp5LH4wUVwWDb4M5umizBys3NRUlJid8LiEBIpFgpWG9v74LWu1yQcNmDI4mUs++Pq2QpkEhOTsbll1+Oyy+/HCaTCWfPnsWhQ4dw8OBBSKVSyOVyyOVy/P73v4dYLLbqbvhDQugtuPK9WxZsRUVF0Ol0xJlqYGCAdDdYwhGM3Q1HcwehFKDnCthNnVAqqCMiIpCeno709HQwDAO1Wg2VSoXx8XG0t7cjKiqKnL/2hsXDHYz5YBiGbMw4AusgFeybD86wJAiGvS9woSJ9dnYWUqkUPB6P2K1yBYEiGHq9HnK5HFqt1i05EJ/PJxcc1y8m9kbp6KZpOW/hKsHyBfwtkTIajairq4NarcamTZsWHEzjclHuaG2Ozk+un7OBBp/PR2VlJSorK3H33XdjfHwchw8fxsGDB3HkyBFMTk7igw8+wAcffAAAWLt2LXbs2IHdu3djw4YNnN/Bc/f7j4yMREZGBjIyMqyyC9hOuOXsRrB0N+xdG7YBem+88QZ27NgRoBX6B+w9Nxi+M09AURTi4+MRHx+PvLw8GI1G4qzW0dEBrVY7LzcmPIMxH2x95grBCGUsCYJhD84kUuzudFZWFpYvX845dh4IgjE1NQWpVIqEhARUV1e7JXmwdL7iulTCkmDYwrLI9lfuiSP4s4Bnw/MiIyNRVVXl0g5ssBGMhcgvVz8LF5GSkoIrrrgCV1xxBUwmE86cOUNscKVSKWQyGWQymVV3g3Wm4pqV6WK/d9vsAr1eD6VSCZVKBblcDoB7ycz2YHt9hGKAnisIdYJhC4FAgOTkZCQnJwMwD4uz5y+bG8M6VolEoqDszvkCbH3mrHZUq9XhDkaowl4iNk3TJH25vLycszaM/iYY7M5bUVERCgoK3L4gLMMBuQ5HBEOtVkMqlSI6Otrv8xb24K8OhmV4njtkm8tD3u6SHy6TJa6Dz+dj06ZN2LRpE37zm99gbGyMDIp//PHH87ob69atw44dO7Br1y7OdDe8WQBERESQ7gbDMGR2g01mjouLs+pucGVzy/I5GaoBeq6AlYqFclHoDNHR0cjOzkZ2djZomsbU1BTq6uowPj6Ovr4+xMfHEzmVu8PioQR2LsXZeTI7OxvuYIQC7H3J7E46u6uu1Wohl8thMBj86gbkCfxFMNiMg9HRUaxbt47sYrgLLmZ3OII9gjE2Noa6ujrk5ORg2bJlnHi48Hg8GAwGn75HX18fWltbsWLFCuTk5Lj1Wi7P3dgSBoPBgOHhYYjFYrs3fC5836GC1NRUXHnllbjyyithNBqtuhsymQxSqRRSqRRPPPEEEhMTrbobgZiB8yWxpChqXneDnd2or68HwzBITEwkhCNQ3Q32GFAUZRWgt2bNGrz33ntBNVOzWASDRa2/wDqr8Xg8lJeXIzIykpy/DQ0NoGmanL9JSUmckpn7Gq4EIavVak7Xmd7AkiAY9mCZiD01NQW5XA6JRIL169cHhYzH18Xb3NwcZDIZGIZZ9AwKRVEBt1V1B2zyOMMw6OzsRHd3N+c6Wr7cVadpmpgbWIbnuQMu7/pbrk2j0eDs2bPEvCAyMpIUdGKxGHw+n9OfJZghEAhQVVWFqqoq3HvvvRgdHSXOVEeOHMHExATef/99vP/++6AoCuvWrSPOVOvXr/dbd8NfBaXtsC07uzE0NITW1lbExsZ6bCW6GLDn/nvvvYdbbrklZAP0XEF4oHk+2GNib1hcqVRidHQUbW1tiIqKImQjMTGRE91JX8EVghGewQhhsDeJ7u5u9Pf3Y/ny5cjJyQmK3QlPQgLdgVKphFwuR2pqKkpLS71yIwgmgsF2B6RSKWZmZgI+b2EPvjqeer0eUqkURqNxXnieO+B6Uc4wDJF/ZWdnIzc3FwzDkPTblpYWGAwGskPnqqV1GJ4jLS3Nqrvx5ZdfEmequro61NbWora2Fo899hiSkpJw/vnnE2cqT7urCyFQ5zBFURCJRBCJRCgoKIDBYCC7w6yVqKUzVVRUlM/WwjAMPvroI7z66qsAQjNAz1VwMcU7kGDtWG2PieWweH5+PoxGIyYmJqBSqdDW1gadTgexWEzO31CbRQgTDDOWBMGwd+IaDAZQFIXh4WFUVlYiISEhACvzDL7qYDAMg56eHnR0dHgki3GGYMrCAIC6ujrExMSgurqakw9SXxCMmZkZnD17FmKxeNGdPC4TSoqiMDIygr6+PpSVlSEzMxM6nQ48Ho8MNC5btgwajYbsIM/NzeHUqVOku7FU9MWBeugLBAJUV1ejuroa9957L0ZGRogz1SeffAKVSoV3330X7777LiiKQkVFBeluVFRUeHV3lAuFj1AoRFpaGtLS0qx2h0dGRtDW1oaYmBiyOywWi712btI0jbvvvpuQi1AN0HMVYYmUNVgCvtD1JhAIkJKSQmSOs7OzhDD39PSAz+dbmR0EesZxsXCFYMzOzoYlUqGIqakpyGQyUBSF8vLyoCIXgPli9rb+3mg0oqGhAZOTkz4hXFzW5FtifHwcBoMBEokEq1ev5uyD1NsdAlfC89wBVzsYNE3DaDSiv7+fyL/sOUhRFIW4uDjExcVBIBBgbGwMWVlZ83aQA62P9we48D2mp6fjqquuwlVXXQWDwYAvv/wSBw8exKFDh1BfX4+zZ8/i7Nmz+N3vfgeJRGLV3ZBIJB6/Lxc+uy1sd4cNBgMmJiagVCrR1NREgtIWq33X6/W44YYb8O677wIAHnzwQdx6661e/CTBh7BEyhqe5oLExMQgJibGalhcqVSit7cXjY2NxMo5KSmJU2YHriI8g2HGkiIYDMNgYGAALS0tKCwsxNDQUKCX5BG83Q1gHZKioqJQU1Pjkx17dq6Bq2AYBl1dXejq6kJkZCSys7M5fVPzVofAcs5k9erVXhvY5CLBMBgMZK5o5cqVbs2WUBSF1NRUpKam2tXH27r/hHc5fQehUIiamhrU1NTg/vvvx9DQEJnd+OSTT6BUKvGPf/wD//jHP0BRFNavX4+dO3di165dWLduHaeva08gFAqtzk1b7Xt0dLTVXJErn982QO/mm2/Gz3/+cz98Gm4jLJGyhit2rAuBHRZn78dsUKVKpbIyO2AlgcEwLO6qRGoxmx/BgCVBMCiKgslkQmNjIxQKBSoqKiCRSDA2NhYUu+q28CbBYDM/cnJyUFJS4rObJ5c7GEajEfX19ZiamsKmTZtQX1/PaTIEeIdgsJ97enra63MmXCMYGo0GtbW1iImJQWRkpFXHgdURs8mr9vTElp/FVh9v6f4jl8tJcjNb1AV7u5/ryMzMxNVXX42rr74aBoMBp06dIla4DQ0NOHPmDM6cOYPf/va3SE5Oxvnnn49du3Zh+/btCz7ggyEc1BL2tO/sudnc3Ezmithz016xZhug99e//hWRkZFBdRx8hbBEyhrs8fBm3WAZVMlu5qhUKiIHjI6OJvdX1oiDawhLpMxYEgRjdnYWX3zxBdn5Ygfi+Hx+UA5veqMbwDAM2tra0N/fj/Lycp8nUnO1g6HRaCCVShEREUG6N1yeH2Cx2AKeTaoXCoU+mTPh0jFkh7nZ4Mzjx4+TY8cwjNU62fsB+9CkKGrBgsLSPYVNblYoFOjr60NzczNEIhEp6OLi4sIFig8hFAqxefNmbN68GQ888AAGBwetuhsKhQLvvPMO3nnnHfB4PKxfvx67du3Czp07sXbtWruFUjB/XwKBwKq7wc4VjY2Nob29fV6x1tPTYxWg9+6776KsrAwnT54M6uPgLYQlUtbw9fGw3MyxHBZXKpVobW2FXq9HQkICkVNxZVjc1Q4G18xjvI0lQTAiIiKQmZmJ/Px8q4vB125MvsJiiZFer4dcLodWq0VVVZVfWDQXOxjj4+OQy+XzEtu5VBw7wmLWqFKpIJVKkZGRgRUrVvjkAcGVDkZ/fz9aWlpQWlqK7Oxs8u80TVv9LyIigpAN9n/s+Woymci/LXSsLJObi4qKoNPpoFQqib6Yz+cTspGUlMR5S+xgR1ZWFq655hpcc8010Ov1pLtx8OBBNDU14csvv8SXX36JRx55BCkpKdixYwd27tyJ7du3IykpKdDL9yos54ry8vKsirWWlhY0NzfjoYcewsTEBHJzc/HRRx+huLgYs7OznCjauICwRMoa9hykfAnLYXGGYciwuEqlQldXF4RCIZFSBXJYnKbpsIsUlgjBEAgEKCwsnPfvS7GDMTU1BalUioSEBFRXV/utwOFSB4NhGHR3d6OzsxMrV65EZmam1c9DmWCwBffy5cuRm5vrg5WZEWiCwTAMWlpaMDQ0hPXr11sVi2zKuKV+mO1UWAYtsju+AwMDEIlEdrsbCz1cIyMjkZmZiczMTNA0TWxwu7q60NjYCLFYTAhHTExMuJDzISIiIrBlyxZs2bIFDz74IAYGBogz1aefforx8XG8/fbbePvtt8Hj8bBx40asX78e1dXVPpWPBgqWxdrhw4dxzz33YHZ2FiUlJbj77rsxPj4OmqZDvghyB+EOhjUCeTwoikJsbCxiY2ORk5NDMs1UKhV6enrQ1NREksX9PRtnNBoXNP4ID3mHCBydVMHcwfBk3WxxWVxcjPz8fL8WM1zpYLjilhUMBMPdAp6mabS0tGB4eHhewe0LBPIYGo1GyOVyzM7Oorq6GjExMeRnrKZ+fHwcUVFRDm/wPB4Pk5OTkMvlSEtLQ3FxMRiGIV0Oy3OZx+OR/zkDj8cjO2slJSWYm5sj3Y2uri5EREQQssGVIKpQJjzZ2dm49tprce2110Kv1+OLL74g3Y3m5macOnUKp06dwvPPP4/U1FSr7oYn4ZNcxTvvvIMbbrgBRqMRW7duxd/+9jfExMQQMtzd3Q2GYSCTyUjnbamS4fAMhjVc2an3F1ir26SkJBQXF5PusUqlwsDAAABYdTd8mR2z0HFhuy+hTt6XBMEA7BdkwZbNwMLddZtMJpLMzA64+xtc6GDMzs6itrbWat7CHrhChpzBnQJer9dDJpPBYDDMK7h9hUB1MNjvOCoqClVVVVYtcnaYOz8/H0NDQ/jiiy8QFRWFlJQUJCcnk1A9ABgeHkZTUxOWLVs2Lw+G7W5YSqcs7RptuyGOEB0djezsbGRnZ8NkMhG5SltbG/R6/YLDuGF4DxERETj33HNx7rnn4qGHHkJ/fz8OHz6MDz74AF9++SXGxsbw1ltv4a233gKPx0NlZSXJ3eCynfVCeOaZZ3D33XcDmB+gx2bCZGRkEHKhVCrR2dnJSTLsD4QlUtbwt0TKHVh2jxmGwfT0NFQqFYaHh9Ha2oqYmBhCNrw9LB6ewTBjyRAMe+Dz+dBqtYFehttwh2DMzc1BKpWCoijU1NQErFAJdNGuUCggl8uRmZlpNW9hD8HSwXBljTMzM6itrYVIJEJFRYXfJHGBIBjsbIm979jSKSo9PR0ZGRnEYUehUKCxsRFGo5HkYkxOTmLNmjV2E6LZv8s+QNiOBks82O/FHSkVn88nBR27u6VUKjE+Pk6Gcd21Gg3Dc+Tk5OCHP/whNm/eDIPBgPHxcZK70dLSgi+++AJffPEFHnroIaSlpWHHjh3YtWsXtm3bBrFYHOjlLwiapnHPPffg2WefBQDceOONePTRRx2eVzweDzk5OUSKwqYyt7e3Q6vVLhmpX7iDYY1gkYxRFEVm4woKCqyyY1paWmAwGMg57I0OXTjJ24wlTTBCXSLFuuekp6ejtLQ0oDeCQHUwLNPJy8rKkJWVteBrgoFg8Hi8BQv40dFR1NXVoaCgAEVFRX59MPqbYAwMDKC5uXnebImlrIl9GLLHwdZhZ3p6Gk1NTZidnQVN02hvb8fExASSk5OdJndbyqNsuxueSKkstcW5ublkGFehUJAgNX+G/HFhWD9QYBgGQqEQ5513Hs477zw88sgj6OvrIza4R48exejoKN588028+eab4PP5qKysJM5Uq1at4lxBahug9/DDD+OWW25xuE5bq15LMgyAkGHLQVvL7kYoGRkES0HtLwTr8bDNjmHPYbZDx57DSUlJSExMdHtY3FWCEZ7BCBGEmkSKLZrsXdyWQ8y27jmBAo/Hg16v9+t7mkwmNDQ0YGJiwq10ci7IuRaCMxJkGRq4atUqn1sQ24O/SBprtzwwMDBP/mdJLNg1OSqi9Ho9WlpaIBAIsGXLFlAUBaVSSTpfDMNAIpEgJSUFEonEqbwOcNzd8GRQ3NY5hQ1SY1v9sbGxViF/wfjA5zJsz5nc3Fz8+Mc/xo9//GPodDp8/vnnhHC0trbi5MmTOHnyJB544AGkp6cTKdW2bdtcvgf5CrYBes899xyuuOIKp69ZKAuETWVmuxvs7EZnZyfm5uaIjahEIuGMjainCEukrOFKIc112G7osOewSqVCd3c3GhsbIRKJyKZOfHz8gufwQsdFr9fDaDSGJVKhDIFAELQuUoB9/aNlaJw7RbWv4e+inc15EAgEqK6udmuX11X5USDhqIC3HGLftGkTRCJRAFbnnw6G0WhEXV0d1Go1qqqqrNrNlpIowHnS7PT0NGQyGZKSklBWVkZ+l822YBgGU1NTUCgU6O3tRUNDAxISEsgurrMHjm13w54NruXvudLdsAxSMxgMZOeNTb21tMH1dr7JUsNC53BkZCS2bduGbdu24dFHH0Vvb69Vd2NkZARvvPEG3njjDfD5fFRVVRHCUV5e7tdie2xsDJdccgmkUiliY2Px+uuvY+fOnQu+zp2wQUsbZgBWRgbd3d3ERjRYbZqDdcfeVwjF42F7Dmu1WhJW2d/fDwBW57C92mKh2RS1Wg0A4Q5GKCOYOxiA+SS2bN2p1WpIpVJERUU5HWIOBPw5g8FKwzzNeeDxeJwnnvYKeHbehs/nB/z79zXBmJubw9mzZxEZGYnq6up5w9z2JFH2MDY2hoaGBhQUFDh0VqMoCmKxGGKxGMXFxdBqtaS70dPTYyUZkUgkDosme1Iqdp2edjeEQqEVEZqeniYPwqamJquQP1d23sKYD3eOWV5eHn7yk5/gJz/5CbRaLeluHDx4EO3t7fjss8/w2Wef4f7770dmZiZxptq6datPN4O6urrwve99D93d3SRAb/369S69djFp5rZGBlNTU1Y2zQkJCaRYC4YQSi65JnEBoUgwbBEVFWVlNT4zMwOlUonBwUE0NzeTDjI7LM7WOs7OE5Zg+MNwJZBY0gQjWDsYbOFhWbCPjIygvr4eeXl5KCkp4dyN2h8dDIZh0Nvbi/b29kVJw/h8vt/lXO7CtoMxMTEBqVSKtLS0gM/bAL7tArGfNT09fR6BtJx/cEYu2HOlq6sL5eXlSE1Ndfn9o6KikJWVhaysLJJtoVAo0NnZifr6eiQmJhLC4WhY0JGUajE2uJaDjIWFhdDpdGSIva+vj9g4JicnB+XucSCwGJIcFRWF7du3Y/v27fjtb3+Lnp4eQjaOHTuGoaEhvP7663j99dchEAisuhsrV6702j1cKpXi4osvxvj4OPLz8/HBBx+guLjY5dcvhmBYwtJGlLVpZneGbUMoPdG9+wM0TXNyXYHCUiNclkGqhYWFMBgMJOivqamJGIUYjUbo9XqH1w5rURvo57SvsWSeMPa+5GDtYABfr50dRu3v78fq1auRlpYW6KXZha87GOy8hUqlwsaNGxfl5BJMQ94Mw5CdFF+H57kDV4bQPcHg4CCxj83Ly7P6maX8yBm5oGkazc3NUCqV2LBhw6JkZJbZFsuWLcPs7CwUCgUUCgU6OjoQGRlJyIYzO09Hg+KO5khcDfnLyMhARkYGaJomu8esrjiUtPG+hLeOS35+Pn7605/ipz/9KbRaLT777DPiTNXR0YETJ07gxIkTuO+++5CZmUnIxtatWz0+Rz/++GNcddVVUKvVWLNmDd577z23nxHeIhi2iI6OnkfUbXXv7PnJle6Gr45FsILLNrX+gFAoRFpaGtLS0kgwq6VkNTIyknToEhISiKpArVZ75Z577NgxPPHEEzh79iyGh4fx4Ycf4sILL3T6mk8//RS33347GhsbkZOTg3vuuQfXXnvtotbhCEuGYNhDsCZ5A19b7La0tECv16OqqorTej5fdjBYaRCPx0NNTc2iXXWCgWCwN6bm5mYMDw8HLN/EEbwtkWIYBu3t7ejr68O6deus7GNZomWbzG0Per0ecrkcJpMJlZWVXg9biomJQW5uLhkWZDsIzc3N0Ov1pIOQnJzs0DJ6oe6GJza4PB4PiYmJSExMRHFxsdXuMauNZyVelkRoqRdTvpL5RUVF4fzzz8f555+Pxx57DF1dXWR24/jx4xgaGsJrr72G1157jcyRsc5UpaWlLn0v9gL0PCEq/iiqLYm6pQxRpVKR7oal7j1QXYSlIAlyB0utg+EMFEUhLi4OUVFR6OzsRHV1NSEcnZ2duP3228Hj8XDeeechIyPDK/IojUaDNWvW4Ec/+hEuuuiiBX+/u7sb3/zmN3H99dfjzTffxJEjR/CTn/wEGRkZ2L1796LXY4slTTBYm9pg3JVgGAb19fWQSCR+zTfwFL4q2n1hxRsMBIMtppVKpd/C89yBNwkGa1wwMzMzj0i7M8ytVqshk8kQHx+P8vJynz8Y+Xy+lfuTRqOBQqHAyMgIcX9iyYa3bHDdCfljd48tnX/YXAM25M9oNHJqlisQ8MezobCwENdddx2uu+46zM3N4cSJE4RwdHZ24vjx4zh+/Dh+85vfIDs7m3Q3zjvvPLtONM8++yzuuusuAMDevXvx4osverzxEojno60Mke2+9fb2oqmpCfHx8QGZLQq7SFmDpuklf3+wBXtPjoiIQFRUFNn4e/XVV7Fv3z4cOXIEf/rTn2A0GvGDH/wAu3fvxq5duzxSn1xwwQW44IILXP79F198EQUFBXjyyScBAKWlpThx4gT+8Ic/hAnGYuBIIgUEHwvv7++HTqdDZmYmJ33W7cHbcjTLeYsVK1bMS1teDLhOMNRqNc6ePQsAWL9+PefIBeA9gjE3N4fa2loIhUJUVVVZPczcGeZWKpWoq6tDTk6O3zNBgK93t+Li4qzcn2xtcFnC4akNrqchf5auKawnvEKhwMTEBAQCAWiaJt2NpVRgBSIDJDo6mhAIAOjs7LTqbgwMDOCVV17BK6+8AqFQaNXdWLZsGe69914888wzABYO0HMFgQ6Xs+y+AYBOpyMylP7+flAUZdXd8GXBG+5gWGOpS6TswWQy2b3vLlu2DMuWLcNtt92GN998E8888wzy8/Px9NNP49prr8WaNWuwe/du7N6922cmLSdPnsSOHTus/m337t249dZbvf5ewBIiGPbA7vobjcagIBgmkwnNzc0YGxsju5/BQC4A785gmEwmNDY2Eg09++DxFrhMMMbGxlBXV4fc3Fx0dXVx9rz1xpD35OQkpFIpUlJSrOxjAdeHuQEzIW9ra0NZWRkyMjIWtSZvwZ77k0KhQH9/P9Gfs2RDJBK5bIO72JA/wDrXgJVg0jRNEm8tQ/68LTELYz6KiopQVFSE66+/HnNzczh+/DgZFu/u7saxY8dw7Ngx3HPPPVb3roceegg///nPF/2M4FqHPzIy0srVh3VO6+vrI85p7Dnq7NrxBIEmW1xDmHDNhyvZIDqdDunp6Xj44Yfx8MMPY3x8HIcOHcKBAwdw+eWXo7i4GCdOnPD62kZGRuZ1StLS0jA9PY25uTmHsl1PsaQJBisnCIZBb3bOgKIo1NTUoL6+PijWzcJbMxiW8xbV1dU+KXC4SDAswxPLy8uRnp6Orq4uzq2TxWKHvIeGhtDY2IiSkhLk5eVZPdTdGeZua2vDyMgI1q9fv6jBf1/C0v2pqKiI7NCy7k88Ho+QDWf6c8vuBnteLDbkj8fjITo6GiUlJVZDjKOjo2hra0NMTAwhG85kXsEKrhXX0dHR2LVrF3bt2oUnnngCHR0dhGwcPXqUfMd//OMf8cMf/tAr78m1Y2AJHo9HLKTZa4edLRoYGCDdDZZwLHZXOFxQWyPY1B/+gCcp3ikpKfj+97+P73//+2AYBuPj475epl+wZAiGI3/7YHCSYmUUlnMGwbBuS3ijg6FSqSCTyZCamjpvR9ub4BrBsEwktwzP43IgICuRcrc4YRgGHR0d6O3txdq1a5GSkmL1M1eHuQ0GA+rr66HVarFp0yav78z4ErY7tLY2uGKxmBAOR04k7LXh7ZA/VuaVl5dHLBqVSiUaGhrAMIxVdyOszfY9iouLUVxcjBtuuAG9vb1YtWoVAHiNXADBNXdg65zGZhYMDAygubl53uyGu58rmI6FPxCWSM2HKwSDtam1B4qi3LJNdwfp6ekYHR21+rfR0VGIRCKfPCOXDMFwBC5nYTAMg66uLnR1dc3LdQg2grGYDgbDMOjr60NbW5tfrFj9GQq4ELRaLWpra0nHxnJQ01dWsN6AJzueJpOJpNBv2rTJanjVdpib7T7aw+zsLGQyGaKiolBZWcl5AwRnsLXBnZubIza4nZ2diIiIsOpuuGOD642QP0uLRtsAKraYWyjtnOsIlnWznS1vn+9c7mA4g21mgV6vJ85UdXV1VoTYUSKzLcISKWuEOzrz4QrBUKvVAXH9rK6uxn/+8x+rfzt06BCqq6t98n7B++T1ErhqVWs0GlFXV4eZmRlUVlbOS3n1R3CdN8EWw+7ekEwmE5qamqBQKHwyb2EPXOlgsIFyjjo2XFmnPVgWs6600FkixefzUV1d7fEw98TEBORyOTIyMlBSUhJyD7/o6Gjk5OQgJyeH2OAqlUoyK+ENG1xLcu0qgaUoCiKRCCKRCAUFBaSYY13eKIoiO8eBtBl1F8FUXLPfm7clK8F0DJwhIiKCdDcsU+9ZQhwXF0fOUZFIZPfeES6orRGWSM2HqxIpe+5v7kKtVqOjo4P8d3d3N2QyGZKSkpCbm4s777wTg4ODeP311wEA119/PZ599ln86le/wo9+9CN8/PHH+Mc//oF9+/Ytei32sGQIhqMbJGtVyyWo1WrU1tYiJiZmXrHFgqvEyBEsixlXb9BarRZSqRQAfDZvYQ9c6AywLf1ly5YhNzfXoQwm0Ot0BHa9rqxvamoKtbW1SE5OxsqVKz0e5h4aGiKBg56muAcTLG1wly9fTmxwR0dH0draipiYGEI2xGKx2za4Op0Ok5OTSEpKgl6vd8sG17KYsxzEZW1GuRiiFuxgnwfhDsbCsE291+v1hKzX19eDYRhi1SyRSEh3IyyRskZYIjUfrpAujUaD9PT0Rb/XmTNnsG3bNvLft99+OwDgmmuuwauvvorh4WH09fWRnxcUFGDfvn247bbb8Mc//hHZ2dn4y1/+4hOLWmAJEQxH4JrUaGRkBPX19cjPz0dxcbHDGzufz4fBYPDz6jwHexMymUwuPQDZ3fuUlJR5RaevEchzgqZptLa2YmhoaMHwPK7PYAALEwz2fC8uLkZ+fr5Hw9zs3MbAwADWrl3LqcBBf8GeDS4b8ldfXw+apq26G47kIOx1ptPpUFdXh9jYWPK9eGqDazuIy4aosYRDIBCQQi4xMZFTkjauEnh7CHcwPEdERISVqxsr9xsaGiKZNUlJSUG1qecPhDs687HYGQx3sHXrVqf3qFdffdXua9iNW1+DO3fyAIErnQDW8WZgYABr1qxZcMiHTfIOFljukDoDwzDo7+9Ha2srli9fjpycnIBkFgSicDcYDJDJZNDpdC6F5wWDRMrRzY9hGHR2dqK7u3ve+e7OMDc7AM9KCb1x0w4F2JuPGB8ft5qPcGSDOzk5CZlMhszMTJSUlJCfuWKDy/7/zmAbosaG/HV2dmJubg5isZgQjpiYmIAXt4F+f1fB3gvCBGNxsJX7WZoZGAwGyOVyIvVb6lbNYYIxH564SIUqlgzB4LJESqfTQS6XQ6/Xo7q62qUiiWudl4XA7nQ6WzNN02hqasLY2BjWr1+PpKQkP67wa7CFuz8frKwsLjY2FlVVVS7t4gZDB8Pe+thh7snJSVRVVc0b5maLV1aO4+g70Gq1kMlkEAgEqKysDLsWOYBlwVRUVAS9Xk8Gxfv6+kBRFCEbbN5FSUnJvPDKhUL+PLXBZYfYS0pKSMifUqlEV1cXGWKXSCQQi8V+13sHUweDPf5hguFdWJL18fFxrFixAnNzcxgZGbGyak5KSnIqRQxFhGcw5iNMML7GkiEYjhDoQp0NE0tMTERFRYXL8oBAr9sTOBtMZ+ctGIZBdXV1QG1F2ZuDvx6s4+PjkMvlyM3NtdoxXgjBOIPBfs8URc1zxbLcHV+oOJ2amoJMJkNycjKxbg7DNURERFjZ4E5NTWF8fBytra3Q6/WIjY2F0WiEWq12aIMLzJ/dWKwNLmAd8mcymTAxMQGlUknWZqmL99c9IliK67BEyvdgGAZxcXFIS0sjUkT2HG1qaoLJZCLnaFJSUlDZY7sLT0xblgJckYF7SyLFdSwpgsHqiC0RKImUpRTIXpjYQghGguGogzExMQGZTAaJRIKVK1cGfEfEsmjy5c2TYRj09PSgo6MDK1euRGZmpluv57JECph/vU1PT6O2thZJSUnzvmd3hrlHR0fR2NiIwsJCt6+bMKzBWnmOjIwAANauXQutVguFQmHVQQiEDS6fzyfvzTAM6W6MjY2hvb3dLyF/XCXw9hAe8vY9bJ8JQqEQqampSE1NBcMwUKvVVkGU0dHR5BwNte4G++wJpc/kDZhMJqfddDawNNzBWAIQCATQ6XR+fU/WenV8fNxjKVAwEgx7HYz+/n60tLQ4dUvyN1ydF1kMTCYTGhsboVQq7doQuwIuS6QAawI0OjqKuro6FBUVoaCgwOp7dpVcsISsu7sb5eXlPgsjWkpg7bB1Oh0qKyvJjqtlB0GhUKC1tRU6nQ6JiYmk6Hc0I2RPSuWNkL/Y2FjExsYiNzcXRqOR6OIbGxthMpmsQv5cyTRwFVy4J7mCcAfDt2DJpqNzlaIoxMfHIz4+Hvn5+VbnaHNzMwwGQ0A6cL6Cr2Z+gh2u5mB4w6aW6wgTDIEAGo3Gb+/HhoDxeDzU1NR4PCAWjATDsoNB0zSam5sxMjKyoFuSv+FrgmFpv1tTU+NxMcRliRTwNQHq7OxEV1cXVq9ejbS0NPJzd4a52fmciYkJbNy4cUncnH0N9jyMiIjAhg0b5mVT2OsgKBQKjI+Pk91Z9ueJiYlu2+Cy378n3Q2BQDBv51ihUFi5/rAhf7ZD7O6Ay9eXLXxFMMLhcma4u2Nve45qNBqrDlx0dDQhxYGYL1oswh0M+3B1BiMskQoxOJJI+atQHx8fR11dHTIyMrBixYpFXZjBSDDYDgY7nEvTNGpqaji3k8MOFvuCYLAzN/YyH9wF1yVSANDe3o6ZmRls2rQJIpGI/LulhAZwnsyt1+shk8nAMAwqKyu9uju9VDEzMwOpVAqJROLSDItlByEvL4/szo6Pj6OhoQEmk4kU9K7Y4LoS8udOd4PdOWZD/tidY7lcDgBk11gikbgd8hcsxbUvOxjhIhJW9yp3YWkjzV4/7OxGS0sL6W6whGMhB0EuwNKII4yvsRDBYDdrwhKpJQB/zGAwDIOuri50dXWhrKwMWVlZi/6bwUgweDweZmZm0NzczJl5C0fwRfE+ODiIpqYmj2Zu7MEeYeYKdDodTCYT5ubmHA5zLyQ5AMytZKlUioSEBE6fL8EENhsjLy9vnlzNVdjuzs7MzEChUFilIrNkIyEhweVBcUu5nCUBdTfkzzLTgA356+/vJxa9LBlaKOSPq9eXPYQlUr6FK/crVyEQCEhIpuV8kUKhQEdHB6KiosigeGJiIifve2EHKftYiGBotVqYTKYl0YVf8gTD1za1BoMB9fX1dndxF4OFLF+5CIPBgK6uLixfvpzzw7neJBgMw6CtrQ39/f1Yt24dkpOTvfJ3udrBmJmZwdmzZ0FRFEpLSx06RS00zM0Wwrm5uSgsLOT0+RIsGBgYQGtrK8rKypCRkeGVv2lpg8umIrPFEusYZtndcNRBWMgG15OQP9vEZp1OR2xw+/r6wOfzSWcjKSnJ7oB0sJx34SFv32IxHQxnsDdfxGbDtLW1Qa/Xk2yYpKQkTmTDAOEMDEdYiGCwkvxwByPEYO+i9GUngJUhxMTEoLq62qs+/QKBwO9ZDZ6C9dbXaDTIzs5Gfn5+oJe0ILxVvLPBTOxOvjd1l1wkGGNjY5DL5SgsLER/f7/Hw9z9/f3o6OhAWVkZ0tPT/bX8kIVl2vm6det8mjETERGBjIwMZGRkgKZpTE9PY3x8HD09PWhsbERCQgIhG846CM66G57a4EZGRs6z6FUqleju7rZaGytTCXcwwgSDBTuL4utjIRAI5s0+sZK/zs5OREREWDlTeZtQugqTyRQmGHawEMFQq9WgKIpz0nBfYEkRDHvwlURqeHgYDQ0NyM/PR3FxsddvSuyF7YrnciCh0+kgk8lgNBqRnJwcNBeVNzpEGo0GtbW1iImJQVVVldva74XAJYmUpeXuqlWrkJ6ejsHBQTLIazlzsdAwd2trK8bGxlBRUQGxWOzfDxKCYB3Lpqen/Z52zuPxIBaLIRaLUVJSQixwFQoFuru7rYopRx0E9u8A3g/5S0xMRGJiIoqLizE3Nzcv5I+maczMzCA1NZXzcpAwwfAtAjGLYtndsHR2U6lUaG9vh1arJd0NlhT767sKS6TsYyGCwc5fLIVriruVqZ/gbYkUWyANDg5izZo1PrPSZB/EXCYYU1NTJPegvLycBBEFAxbbHWDD83JycrBs2TKf3Ey40sGgaRqNjY1QKBRWlrvsoLw9Lb09GAwG1NXVQa/XW1mmhuE59Ho95HI5GZAPdNp5VFQUsrOzkZ2dDZqmiQ1ue3s75ubmkJiYiJSUFEgkEqdEyBchf9HR0WRtJpMJk5OTaG5uxujoKIaGhuYVclxDeMjbt+CCJMjS2Q0Amd1QqVTo6uqCUCgk52hiYqJPawMuHA+uge2yLtTBcBZgGkrgZmXqR7ASKW/s0rC79QaDwetyGFuwa+VqwT4wMIDm5mYUFxcjPz8fFEU5TfLmGjxd62LD89wBFwiGXq+HVCqFyWRCdXW1le0yRVFklxlwPhw5OztL5IQbN27kLGkOJrDHNC4uDuXl5ZzbbeTxeKQYWr58ObHx9IYNrjdC/tisgszMTIhEIqshXC4GqIU7GL4FF+16Y2Ksk+/Z2Y3Ozk7Mzc0hISGBnKfeLmrDEqn5cCUbZKlY1AJLjGDYu7gEAgF5IC3mxsymUSclJWH9+vU+L5DYgp1rBIOdtxgeHp430BxMg+me2NR6IzzPHQQ6aG9mZga1tbVISEjAqlWr5iVz83g8DAwMgKZpp4PtKpUKdXV1yMzMRElJCece4sGIyclJyGSyoDqm9oL0FAoFGhsbYTQakZSURAiHo/wgb9vgsuex7dpYi9Hm5mYYjUarADVPs40Wi/CQt2/B9R17S8MCAFaSv+7ubgiFQmKD60yO6Cq4fjwCAVdIvkaj4cygvq+xpAiGPbAngivhKPbADqS2trZ6zX7UVXCNYFjOW1RXV8+TEfjDEthbcLc7YBmeZ7uT7ysEkrCxErC8vLx5M0Zsm3j58uUYHR1FR0cHGhoaiPzFchZncHAQLS0tWL58ObKzswPyWUINo6OjaGxsRElJCXJycgK9HI/gKEhveHgYLS0tiI2NRXJyMlJSUjyywbWXw+Kou2H7t20tRtVqNZRKJUZGRtDW1kZC/iQSCUQikd+KsHAHw7cINqmYreSPNTTo6uoihgYs4fBkJiA8gzEflqGxjqDRaJaEgxQQJhjkoWI0Gt3WJ1vuWG/YsAGJiYk+WqV9cIlgTE1NQSqVQiwWO+zgBFMHwx2JFDtr4u9sDx6PB4PB4Jf3YsEwDHp7e9He3o7y8vJ5VqeWWviEhASIxWIif1EoFBgbG0NraytiYmLA5/Oh0Wiwdu1aTiW5ByvY76arqwurVq1CSkpKoJfkFdgG6RkMBjIoLpPJAIDY4EokEof3cVe7G67mbdiuLT8/HwaDgTj+1NfXg2EYUsQ5W5s3ECYYvgUXJVKugs/nIykpCUlJSSgpKcHc3Bw5T3t7e0n3g/0dVwxJwhKp+WBJl7PzRK1WhwlGKMLel+6p1IjVN/P5fL/tWNuCKzMNbIBcUVGR0+AurqzXFbjawRgaGkJjY6PVrIm/4G8XKZqm0dTUhPHxcWzcuNHK4cl2R9h2mNsyBVqr1UIul0Oj0YCiKNTX10MikZDhXm+7bS0FWLpvbdiwwWt5O1yEUCgkNrgMw2BqagoKhQK9vb1obGyESCQiUqr4+HiPQ/5MJhOMRiP5/10hHUKhEGlpaUhLS7MKIGRn0kQiESEbztbmCdjucJhg+AbB1sFwhujoaGRlZSErKws0TWNychIqlQo9PT1oamoi52lSUpLD8zQskZoPV5QwrERqKWBJEQxHcFe6Mz4+jrq6OmRkZGDFihUBu8gC3cFgi5qhoSGsXbt2wR3TYOpgLEQwLMPzXPnsvoA/h7z1ej0xMKiqqrJyeHInmZuVkkVERGDLli0QCASkQOzu7kZDQwPEYjGRvywVrepiYDQaUVdXB61Wu+TctyiKIja4xcXF0Gq1ZBi7p6eHuO6kpKS4ZYNrMpnQ0tICo9GI2NhYq+6GOyF/9gII2VRxNoCQLeQWS6xdGTD1BGGCYUaoFtQ8Ho90LiyvIZVKRboblrMb7HkalkjNhysEg7WpXQoIEwy4blXLMAw6OzvR3d3tc4cgVxBIgsEWnHq93u68hT2ESgfDaDSSHfiqqqqA3Sz8RTDUajVqa2sRHx+PiooKqyLN1XwLwCwlk8lkSElJsSLmlgXi3Nwckb90dnYiMjKSzG04cxJaqtBqtZDJZBAKhdi4ceOS7/5ERUVZ7czas8FluxuOyKvJZEJDQwPUajUqKysRGRnplZA/2wBCVhNvuWvMyrw8cfwJD3n7FsEskXIHttcQe5729vaiqakJ8fHxkEgkmJubC7jtNdfgCsEIS6RCFM6kOwsV6qxHv1qtxqZNmzghQQgUwZienibuQbYFpzOEQgeDDc+Ljo5GdXV1QAs6f0ikWJ17bm7uPDciV5O5AWBkZARNTU0oLi5GTk6Ow9+Njo5GTk4OsV1UqVQYHx8nTkKs1j45ORmRkZFe/7zBhJmZGUilUkgkEpSWlobJlw1sbXBnZ2cJee3o6EBkZKSVDS6fz4fBYIBMJgPDMNi4caNVAWW5QeLtkD9219jS8cfdPANfzWAslcJ6IYRqB8MZLM9TwGzkwp6nCoUCFEXBYDCQ7sZSJxyuSqT8Pa8bKCwpguEIC0mk2Ad5bGwsampqOLNLGAiCwc4cFBYWorCw0K0HT7B3MBQKBeRyObKysrB8+fKAP3R93cHo7e1FW1ub3W6d5TC3M3LBMAy6urrQ19fn9uAxn8+f59YzPj6OwcFBNDc3Iz4+nnQ3vK1n5zoUCgXq6+uRl5fndO4pjK8RExOD3Nxc5ObmEvKqUCjQ3NwMvV4PsVhMdhfXrl1rt1BgC0xvh/zZ7hqzeQYdHR0krZntbjjqFrPvHe5g+AahNIPhKSIjI5GZmYnMzEw0NjaCx+MhIiICfX19pAvHyqlEItGSO29cGXyfm5tbMo6JYYIB5xIptqAuKChAUVERpy4YfxIMmqbR1taGgYEBj2cOgrWDYemcVFZWhqysrACvzgxf5WCwWSYjIyPz3NEYhiGdC8B5MrfJZEJTUxMmJyexYcMGxMfHe7wmS7eewsJCspM2Pj6Onp4eCAQCK619KGuDBwYG0NrairKysnkuXmG4BlvyOj4+joaGBvD5fExMTOD06dOku5GQkODXkD9LTXxJSQlJa2YJR1RUlFXIH3uus+/l7SI4TDDMCHdyrMEwDMmGKSoqgk6nI85UAwMDAOA3BzWuwFWJVDhoLwThTCJl28FgB5gHBwcDNsS7EPxFMPR6PeRyOXQ63aISyoOtg2EwGEDTNBobG6FQKOY5JwUaPB7P6xIpViLCfteeDnPrdDrI5XIAwKZNm7z+cLHcSbPU2re2tkKn01mFsoXK0DPDMOjo6MDAwADWrVuHpKSkQC8pJDAxMYHGxkbk5+ejoKAARqORSEDkcjkYhrGS5i3WBpf9XVe7G7ZpzWzIX0tLCwwGAynidDqd1ft7C2GCYcZSlEg5g+1ufWRkpNWM0czMDCEbbMeZlVL5Mx/Gn3BVIhWewVhCsO1gsDaaRqMRNTU1nLUU8wfBmJ6ehlQqhUgkwrp16xbVfg+2DoZer8fp06dB03TArIidwdsSKY1Gg7NnzyI2NhZVVVUeD3PPzMxAJpNBLBajrKzM590ES639smXLMDs7i/HxcYyOjqK1tdXlUDYug83cmZ6eRmVl5ZLZAfM12FDCZcuWEdmCUChEeno60tPTwTAMpqenoVAo0NfXRwLKWFvlxdjg2lo6u9LdYF2xkpOTsWzZMmg0GiiVSoyOjqKrqwuA2aVmYmLCaefFHYQJhhlhiZQ1nBEuHo+HhIQEJCQkEAc1R/kwSUlJITNPFyYY1lhyBMPeYKxlB2NiYgIymczvoWmegM/nQ6/X++zvDw8Po6GhwaN5C3sIpg6GXq/H+Pg40tLSUF5ezsnzwJsEQ6lUQiaTITs7G8uWLfN4mHv8/7P33tGxnfW5/zMjadTLqOuoH/XedY6O6c244GNMjOFyr8EQbkINccj60UJCuBdjSgKBBMO6EELuNXBdsMEYjLF9DI5NLtLMSJpRr6M6fSRNL3v//jh+X+8pmiJN2TOzP2uxFtZR2Rrteff7fb/f53l0OszPz9PT4ERvTEQiEc3cIMFn5DSahLKRDVqqZG6QDiLLspicnMyIUYNEoFarsba2FlIbJBKJ6EaJjIEQobharYZYLKb3Uyir2dO6G9yxKvLzorHBLSoqQlFREZqbm/H000/Tf1OpVPB6vT4jKmfdxAkFxnWEESlforGplUgkAUW70WikerqioiJ6n6ZydyNSm9pMOSDKuAIjGNnZ2XA4HFTU2tnZiaamJt4vJvHqYHAzHoaGhlBdXR2T70s6GHx/YB0cHGBnZweFhYUYHBzk7bXGykVKrVZjeXkZPT09AeKzaMTcarUa6+vr6OvrQ01NzbmvKxb4n0YfHR1Bp9P5ZG4QoTgfF30S6FlUVMTbQjfVIKNme3t7GBsbQ2lpacRfm5ubGyDGJpbK8/PzVIxN7qezdDeCjVKR/x8JVVVVuOGGG+iIyv7+PpaWluiISrQCXOHk/jrCiJQvZ03y5hbtra2ttLthNBppd0MqlZ67ME4GXq835PWyLAur1XouPWIqIRQYuH7DE0cRf1Ern4lHgUFOSx0OR8wzHsjmiK8FBsuyWF1dhVqtRkNDA+x2Oy+vk3DeDgY3KPE8Ym4iCtfpdFFv2BIJN5Sto6ODZm7odDpqW8qnzA2z2QyFQoG6urqArpLA2SBp9CaTCRMTE+cqKrli7M7OzoAMF4lEQtPpQxkPhOtuRCoU54q8uSF/3E2cwWDA7OwsRCKRT3cjVCePr+t1ohEKLV9iVXD5dzdIYXxwcIDl5WUUFBTQ+zRWY3/xQhiR8iXjCgz/U1+bzYadnR0wDINXvepVKVUtx1rTcHJyQgPVpqamYm53SBaGs558xBOShmyxWHD58mWYzWZYrdZkX1ZIzlNguN1uWkj6ByX6i7nJfHio7+PxeHDp0iXe6VRC4Z+5QUaplEolvF4vnbMPJeyNF0Qb0NHRgcbGxoT+7HSFvMddLhcN0IslwTJc9Ho9lpaW4HK5IjYe8O9uRGqDGyoHg7uJYxgGx8fHMBgMUKvVWFxcRElJCd3EFRUVBYxICgWGkFztTzxeD//C2O1208KYjP1xuxt8e95EWmDwsVseDzKuwOCi0+kwOzuL0tJSMAyTUsUFEHkCeSQcHh5ifn4+rna83BM6PmGz2SCTyZCbm4vLly9DIpHg+PiYd9fpz1lHpGw2G2ZmZlBQUBBUzB2p3sJqtUKhUKCwsBAjIyMp/fDNyspCdXU1qqur6SmaTqfDzs6OT8pyVVVVwAYslhBL5I2NjahzQwROx+l0Qi6XIycnB+Pj4zE/PPHH3wbXarVCr9dT44GCggJabJSVlcXEBtftdgMIn4MhFotpJ4/oSogN7vb2NrKysqhrllQqFQqMlxFGpHxJxEFhTk4OampqUFNTQ7OQDAYDDg8PsbKygoKCAtqJC/U+ShThCgyyFggdjDSGZVmsr69jc3MTfX19EIvF2NzcTPZlRU0sOhjcsaBY6i2CQR5SfHKSIuLmCxcuoKury2dcge8Fxlk6GEajEXK5HBcuXEB3d/eZxdxGoxGzs7NoaGhAe3t7Wm1AuKdo/sLeeGZukJE1rVaL8fFxlJSUxOT7ZjpWqxVyuRylpaV0vU8kXDE2MR4g3Y35+XkwDEM39KFmzoONUnH/x7Va93g8Edvg+ls+k5C/9fV12O12sCyLw8ND1NXVoaCgIK3e69EgjEj5kuiCi5uFRN5HxLJ5YWGBdjdIwZEMe/JwBYbNZgPLsoIGI13xeDyQy+WwWq24fPkyiouLodfrQyZ585XzajDIeIvNZou53iIYIpGINxt3IkpeWVkJKm6Od0p2LIg2aI/4kXd3dweM3UQq5ibfh4jC/RO+0xF/Ya/JZIJOpwvI3Kiqqjpzy97j8WB+fh52ux2Tk5Npk92RbI6OjiCXy1FfX8+bQtj/VJbY4O7s7EClUtFuWWVlZUgxtn93g/v9YxXyZ7fb8Yc//AHHx8fY3d2FRCKh4ylSqTSlu5bRInQwfEn2yFhOTo5P15lYNmu1WqyuriI/P5/qn7iBlPEkXIFBxq6FDkaaolKpAABTU1NU2JbIROxYcp7rPjk5gVwuR2Fhoc9rEW/4kIVBhJ7kpDiYqD8VCoxIg/ZYlqWhkaOjo6ioqPD5t0jF3MRd7ODgAKOjoyljhhBLuJkb3NGXw8NDmrlBdBuRZm44HA4oFArk5ORgYmIiJaxzUwFimdze3o6mpqZkX05Q/G1wXS5XgA0ut7sRygaXrFcSiQQSiSQmIX+k0O3p6YFEIqEnxisrK3C5XD7z8OleFAs2ta9ARvT4UnD5WzZ7PB7qTEUCKcm9Wl5eHrdss0gKjKysrJQbxz8rGVdg9PX1BYhWs7OzM6qDQfQWLS0tCT/VS3YHw+l0QqFQwOv1BiRVc0mVAoMs9Kf9DT0ej0+Xiisu485zA6HF3P4n7HwNn0wkwUZfyOZQLpdDJBLRzkZFRUXQ2XhS6FdUVKCnp4c3D+xUZ29vD8vLy+jt7UVtbW2yLydiJBKJz7jS0dER9Ho9tVUuLS31sVXmvl+5Iu9YhfyRAwjSfSadFZZlYbPZYDAYoNPpfE6M+TIPH2uEDsYrcO8fPpKdnR20u0Hu1by8PJ97NZZjruEKjMLCQt6+brEm4woMiUQSUEyQjXqqidmivW6it9je3sbg4GBSsgqS2cE4Pj6GTCZDWVkZBgYGQi4EqVBgkL/5aX9/f/E69/STu+EINzpht9uhUCiQm5srnLCHICcnB3V1dairq/PZHJKMBKlU6pORYDAYMDc3h+bm5qSEEqYjLMtic3MT29vbGB4eRnl5ebIv6cyIxWJIpVJIpVIfW2WuDS435I881/wL2fOE/HGd5LhwAy2bmproiTF3Hj4WIX98ItX2B/GE7wUGl2DdDdKJI92NsrIyeq+e5/AsXAfDYrFkzHgUkIEFRjCysrJ8TmpShWhyJdxuN+bm5mC1WjE1NZW0mzxZHQzStYk0lTwVCgz/TQAXk8kEmUyGuro6dHd3+zwIohFzm81mzM7OoqamBp2dnSnxQOEDwTaHOp0Oer0eq6uryMnJgcvlQktLC1paWlJq3eErLMvSPJbx8fG0E1L62+CaTCbo9XqqBdJoNADCu/RFE/J3WoHhj/+JMXH7IVkGhYWFPlkGqXi/Cx2MV+CO1KYa2dnZPg5vpBOn1+uxtraGvLw8WhxHozMincFwHYxM6v4LBQZeOfHxeDwJ97s/D+RGDmcXZ7FYIJPJUFBQkFC9RTAS3cEgqb1bW1tRuWSlUoHhv6jt7e1hYWEBXV1dAbPn0RQXBwcHWFxcFLIYYkB+fj6amprQ2NiI1dVV7OzsoKKiAvv7+9jd3aVz9snI3EgHvF4v5ufnYbPZMDExkfZ6gGDjSj/4wQ8AADs7O3jxxRcjtsEl3w8I7G7Y7XYA119fr9cbkVA8mNsPscElSc2k2CgvL0+Z+51PmoNkE8nzIxXw78SRwp2rMyotLfXpboQKnAWC59AQbDZbwGhjOiMUGPANgEsluAXGaUWDRqPB/Pw8mpqa0NHRkfQbO5EdDKIbOD4+po5hkRKJviHZ+HcwiAh7d3f3VDF3JE5RxMZ5Z2cHg4ODqKysjP8vkwEwDAOVSoWjoyNcunQJRUVFp2ZukDn7eGZupAtut5tqXjJxhI9skoiDWWdnJ9ra2qgNLgmNJAVHqHElbnfDYrFAqVSitrY2IHMpGqF4Tk6OT1IzCfnb2dnB4uIiiouL6QauuLiYt/e70MF4hXR9LfwLd7vdTovjjY0N6qJWXl4OqVTqM44YSVdHGJFKc4ItXkTAlmpCb3KaFKww4p7cDwwM8EbomKgOBtEfSCQSTE1NRX1Kxt288/WBR66LeOBzk8hDiblDFRderxcqlQrHx8eYmJjIqMUwnrhcLszOzoJhGExOTtL78bTMDZ1Oh83NTeTk5PjM2WeSLWgk2O126obX39+f0a8PWVf9bXBPTk6g1+tpZ7O4uJjeU6eNK52cnEAmk6G2thadnZ0BBxRntcHlumZdvHjRJ+RPrVYjKyuL2j6Xl5fHPRAxGgQXqVdItkVtIhCJRCgoKEBBQQEdSyQZMWtra3A4HFS7UV5eTu//UO+BTErxBjKwwDiNWKZiJ5JgTlL+m00+zSInooNBwuSC6Q8ihTt+xNeTGuL+YrPZsLi4SIupYGJu0uUI9bsQhy2xWOyzCRY4HzabDXK5HEVFRWE3wdzMDe6c/dLSElwuF8rLy2l346yZG+kC2QRXV1cHhEZmIuQ5wN2UcwvYixcvwuVyUTcdrtMZ1wbXZDJBoVD46IPIa+s/SnVeG1z/kL+joyMYDAZsbm5CpVL5jKcke7SEz8+CRJOIFG++QRLuyWSAzWajxgYbGxvIzs4Gy7LQ6XQB3Q2CUGBkKKnYwQACCwyLxQK5XI78/Pyk6y2CEe8OhlqtxvLyctAwuWgIFmDFV+RyOWprawNsTqPRWxwfH0OhUKC8vBy9vb0Z9/CIF2azGQqFAnV1dejs7Ixqg8Rt13d1ddHMjYODAywtLaGoqIja4IYKZEtHSJK8IJJ/Ba5N7WlIJJKgTmfEBregoAA2my3s63qaUJx0Os4a8keMEdrb22G32+kGjtvNS1bIn6DBeAWh2ALtbjQ0NMDr9WJvbw+bm5tYX1+H3W6nxbHZbMbAwADEYjGsVmtMpgL++Z//GV/96ldxeHiIoaEhfOtb38Lk5GTQz/3hD3+Ie+65x+djubm5cDgc576OcGRcgXHagpkOHQytVou5uTk0NjZGvZlJFPHqYDAMg8XFRWg0GoyNjZ3bnjIVdDn7+/tgWRaNjY0B+hruAz9ccaHVaqFUKtHa2ips1mKIRqOBSqWKSdCbf+YGOYnW6/WQyWQQi8U+J9F8Gi2JNYeHh1CpVBmTJB8pkRQYXPydzra3t7G6uori4mJsb29jf3/f55467fueJhSPRcgft5tHxlNWV1fhdDpjZi0aKcKI1CtkwohUNGRlZaGwsJBawhPtxs7ODm6//XYUFBTghhtugMViQXNz87l+1k9/+lPce++9eOCBB3Dp0iV84xvfwI033ojl5eVTTWxKSkqwvLxM/ztR93H6PoWiJJXTvD0eD9bW1rC5uYn+/n7U1dUl+7JOJR4dDJfLBblcDo/HEzI8LxrIWAAfOxgkz0StViM7Oxs1NTU+mRjRiLm3t7exsbGB/v7+iB22BELDfV0HBgZQVVUV858R7CRap9P5ZG6QUap0skXc3t7G+vo6hoaGBPMBP0jX4CwbP7VajfX1dYyMjKCiooJu6HU6HVZWVuBwOKg2Itw9FauQPy7BxlP8rUWJkD1eIX9CB+MVMnFEKhzcDIz8/Hw0NDSgoaEBW1tbePrpp/GrX/0Kzz77LK5du4a1tTXcdNNNuOmmmzA0NBTVhv8f/uEf8MEPfpB2JR544AH88pe/xA9+8AN86lOfCvo1IpEoKTpcocB4mVRN8xaLxdjY2IDb7ead3iIYsS7kyBx2SUkJxsbGYnpym+zU8WAQZ6yTkxNcvnwZf/zjH+k1RiPmJh0fg8GA8fFxlJSUJOx3SGcYhsHy8jK0Wm3CXlfuSXRnZydsNhsViq+srKCgoCAiy1I+Q4rq/f19jI2NobS0NNmXxDui7WAArzjG7e7u+ryu/ht6Mp5H7qn8/Hx6T0ml0jPb4IYK+QsFV3zLDU5bXFyEx+OBVCql1x8rrZIwFvQKwmsRyGkhe/n5+bjttttw2223we1248KFC+ju7savfvUrfOlLX0JRURHe+ta34qabbsKb3/xmSKXSU3+Gy+XCzMwMPv3pT9OPicVivOlNb8JLL7106teRzgnDMBgdHcWXvvQl9PX1ne8XjoCMKzBO23ClYgfDarXi5OQEeXl5Z3JKSgZisRgulysm30uj0WBubg6tra1oa2uLeduPb1kYDocDMpkMWVlZuHz5MiQSCQ3DikbMTRyNvF4vJicnM14sHCtI8We32zE5OZm0LIaCggI0NTX5JCzrdDrMz8+DYRhUVFSgqqoKFRUVKbFmcO19Jycn06ojE0tOS/I+Df9gwlCz4SQrgCQhG41G6PV6qFQqeDwen+5GqPUkmpC/SEep/IPTrFYrDAYDDg8PaYHNDfk7y8Y4FYN444kwIhVIuBRv4Hrnrb6+Hn/2Z3+GP/uzP4PL5cILL7yAX//61/jiF78IrVaLj370o6d+vV6vh9frRU1Njc/Ha2pqsLS0FPRrurq68IMf/ACDg4M4OjrC1772NVy5cgUqlQoNDQ3R/6JRkHEFxmmkmshbp9NhdnYWubm5aGhoSImNAhCbrgA5ddvc3MTg4GDAmy1W8KnAMJvNkMvlqKqq8hFhk5GzSEaigOsnGQqFAsXFxRlv6xlLHA4HFAoFcnJyeJXF4J+wfHx8DL1ej+3tberSQ4TiyXbpCYbH48Hs7Cw8Ho/gbBaGaDoYDMNAqVTi5OQk6mDCYKnder0e+/v7PuYDoWxwgfDdjbPa4BKtUnNzM9xuNxWKK5VKsCxLU5qjKbC5XWEBYUQqGJEUGP45GBKJBG94wxvwhje8AV/5ylfoAWEsmZqawtTUFP3vK1euoKenB9/97nfxxS9+MeY/j0tGFhgikSjgD5kqIm+WZbGxsYGNjQ309fVBr9fzZhMcCefVYJwnPC9a+FJgHBwcQKlUoqOjA83NzT4PbJFIRFN2wxUXBoOBmgDEo+OTqZycnEAul6OioiLAyYtPcDMI2tra4HA4oNfrodfraYgU0W0kw6XHH6fTCZlMhtzc3JiPP6YjkSQJA9c3QrOzs3C5XJiYmDhX0cZN7W5tbfUxH1AoFABAtRHhNvT+3Q3u/84T8uefCWIwGLC3t0eLIXJ9oUL+IukMZxLCiFQgkXYwQtnUhnsmV1ZWIisrCxqNxufjGo0mYo1FTk4ORkZGsLa2FtHnnwdhxX6ZrKysmI3uxAuyuSZJwCUlJTAajSlRGBHO08Gw2+2QyWTIzs5OyEhYsgsMEpa4vb2NoaGhABE2wzCQSCRYWFigp9Cnub3s7OxgdXUVPT09vDYBSDVI0dbc3IzW1taUKtry8vKoEJGbubG4uAiXy+WT/pzoMTqr1QqZTAapVCrYJkdIJCNSJPVcLBZjfHw85kUb13yAZVlqg0s6ZiUlJXStCpVSH2yUKhYhfyQThFsMGQwGKBQKiEQi2tkoLy/36UJytSICwohUMCIpMM5rUyuRSDA2NoZnnnkGt99+O4Drf4tnnnkm5GiV/3XOz8/j5ptvPvN1RIpQYLxMdnY27HZ7si/jVKxWK+RyOSQSCa5cuUI316mmHTlrB8NoNEKhUKCmpiZhp8TJLDDIIkCKSW6nhqu5GBoaog/xlZUVOJ1OnzA2iUSClZUVHB4eYnR0FGVlZUn5fdIRcgra29ub8kVbsMwNnU7nk7lB7ql4Z26Q7JCGhgah0xYF4UakHA4HzUgaGBiI+wZRJBKhrKwMZWVlaG9v9+mYbW1tITs72yel/rRiJ142uP5ObMfHxzAYDNje3sbCwgJKSkpokU1+tlDoXkfoYATi9XpDjsYSfdB5py7uvfdevPe978X4+DgmJyfxjW98A1arlbpK3X333aivr8d9990HAPj7v/97XL58Ge3t7TCbzfjqV7+K7e1t/Omf/um5riMSMrLACDYixeeNOtFb1NfXo6ury+eNnQqdFy5n6WDs7OxgaWkJXV1d584TiIZkFRhcMbd/p8ZfzJ2dnU1P3To7O33C2BYXF5GVlQWxWIy+vj7BeSdGEA3Qzs4ORkZGzp25wje4c+zck16dTge1Wk0zN6qqqkJuDM8CyWTp6Og4V1BmJhLKptZms2FmZgbl5eVJG+PjdswYhqEds9XVVdjtdkilUlpwhBojiYcNrlgspsUQGR8k3Y3t7W36mur1+lNTmjMJr9eb8a+BP16vN2ynNxZBe3fddRd0Oh0+//nP4/DwEMPDw/j1r39NtahkjSaYTCZ88IMfxOHhIaRSKcbGxvDiiy+it7f3XNcRCcId8jJ8FHmzLEuTIfv6+oKGSvG5MApGNB0MhmGwtLSEg4ODmITnRUsyCoyjoyPIZDJUVlair68vIJk7lJibuzGsqamhAWz5+fmYn5/3cVvhw4x9KkIcjcxmMyYmJmKSysp3/E96zWYzzR+w2WwR5yOEY3d3FysrK+jr64ubcUM6c1oHg1h519XVBQRyJguxWEwPRrq6uqi1Mik48vLyaBFbVlYWdcjfeW1w8/LyaMgfwzA4PDzE0tISTWn2D/njw2uaSIQORiCRjI2F02BEykc/+tFTR6KuXbvm89//+I//iH/8x3889888C0KB8TJ8E3l7PB4olUqYzWZMTk6eevqcagVGpB0Ml8sFhUIBl8uFqamppFhTJrrAODw8xPz8PNrb2wMStbmndOHE3CaTCbOzs3RDQX4Pk8kEnU6HxcVFuN1u2v6vqqoS3HkigNj7MgyDyclJ5ObmJvuSEo5YLEZ5eTnKy8tDZm5UVVVFbAlKjCvUajVGRkZC+sALnE6wAsNkMkGhUKClpQWtra3JurSwcK2VvV4vFYqrVCqftSrWNrjk/4dCLBajuLgY2dnZuHz5Mg35MxgM1ByBiNhDFUPphKDBCMTj8YR8TRiGiUkHI5XIyAIj2OaMTxt1m80GmUwWoLcIBp+uOxIi6WBww/NGR0eT1oqNR+p4MLjOYKeJuSO1od3f38fi4iI6Ozt9Rkz8TwwtFgt0Oh329vawuLiIkpIS2t3go11psrHZbJDL5SgqKhLsfTn4Z26QjeHs7CxYlqWbwsrKyqDzyaRLqdfrM6YjFC/IWkXWS5J90tnZGXe/+1iSlZUV1AaX6IEKCwt9bHDPGvIXjVCcm+LNDfkj5ggGgwFLS0twu90+IX/JysKJN0IHI5BwRZfVagUA3ochx5KMLDCCwZckb/JwvnDhQoDeIhipVmCE62BotVrMzs6ipaUF7e3tSd3okhC7eOL1eqFUKmEymQJsd7libnI9oWwU19bWsLu7i+HhYZrAGwyuteTFixfhdDrpKTTXrpSMUmX6g4SIjuvq6tDZ2SkUX6eQnZ3tYwl6fHwMnU7nk7lBhOKFhYVgGAZzc3NwOBxC4GMM4HYwyEFDf39/So+b+dvgut3ugCKW292Ilw0uwzCnHkySn006egaDAVqtFqurqzEJ+eMjQg5GIOFcpEiBEYsRqVRBKDBeJtkbdZZlsbW1hbW1NfT29qK+vj6ir4tFcF0iOa0rwD3FHxgYiNjTOZ7Ee0SK+PyLRCJMTU35jNz4i7mJWDEYpEg5OTnB5ORk1AtYbm4unTf2er00+VmlUsHr9aZc8nMs0Wg0UKlUaG9vT6jBQKrDzdzgOgjpdDqsr69DIpFQm+XR0dGMHDeLNeSATK/Xw+l0hj1oSEVycnJQW1uL2tpanyJWrVZT5yey4Q+Va+FfbAAI2d2IZEMtEolo4jnp6JGQP7KWckP+UvmeF0akAgl3j9hsNuTk5KT03z1aMrLAOO0kIlkdDO4pdii9RTD4KE4PBSmIWJalfwdiyWo2m2m+Bx+I54jU8fExZDIZysvL0dfX57NYhxNzcyEJ0tnZ2TFJOs7KyqLdCxJMFewUmoxSpSssy2J7exsbGxvo7+8PGFsTiA6ug5DFYqEuaW63G//xH//hY62cSQ/gWELWqsPDQ7zuda9Le9c4/yKWdGKJDS63u1BRURHWBjdUd8PpdEIkEsHj8URsgxsq8Xx5eZmOelVUVMTd+jnWCCNSgYRz1rJYLBk3fpyRBUYwsrOz6cYukW8cMttNwuOifbimYgcDeOUExG63Qy6XU0tWPm0u4tXB0Gg0mJubw8WLF3Hx4sUzi7mPj4+hUCjiliDNDaYi1o06nQ56vR7r6+vIy8ujm8KysrK0eeAwDIPl5WVotVqMj4/zpuBNB46PjyGXy1FTU4Ouri4AoBsvogcqLi6mQvFQp9ACr8CyLJxOJwCgv78/7YuLYHA7sVy3s/X1dczPz6OsrIzeV6Gcn/y7G8fHx1hfX0d9ff25Qv78E89Jd2N2dhYAaGejoqIiZJ4CHxBGpAIJ95qQAiOTEAqMlyEnyB6PJ2FjICRBtK6uDt3d3Wd6wyZ7tCtauII7stmorq7mZVpvrF9bru1wsDGwaMTcZHTn4sWLaG5uTsgmLC8vD42NjVTcSLIR5ufnwTCMT5o43x+Qp+HxeDA/Pw+73Y7Jycm0FWkmA5J63tra6nPP+m+8yCk08XMnRWysMzfSBYZhoFQq4Xa7AWSWiPQ0TnM7IwVHbm4u7W6Esuw+OTmBXC6nLlyxDPnzH/Ui9zwpsom2JFTiebIQRqR8IQeDoV4TYlHLt79lPMnI1fq0ESkACdmsc/UWPT0953L4SLUCgyy+u7u7WFtbQ2dnJ5qamnj5phOLxfShfV7IJsBoNAaMgUUr5t7a2sLm5mZSR3f8nV5Imvjm5iaUSiWkUindGCbDYvgskHGznJwcTExMpGyRxEcODg6wsLAQNvVcIpHgwoULuHDhAj2F1ul0NIyNZG5UVVUJxR+uP69mZ2fhcrkCXJMEXsHfBtdoNEKv12NxcREul8sny4XcV0ajEQqFwkd/FY+QP+6oV1tbG5xOJ7XBVavVyMrKop0NvhTZwoiUL+TvHk7kLXQwMhSRSJSQzTrRWxiNRkxMTKCsrOxc3y+YpiEVWF9fx+joKK9FiLEakXI6nZDL5WBZFpcvX/Zxy+HqLYDQYm6GYbCwsACTyYSJiQnenFSKRCKagtve3g673Q6dTueTjUB0G6Wlpby8T09OTqBQKJKadJyOcLUs0YqOuafQXV1dNKXe/74KZ1earrjdbsjlcojFYoyPjwfY1AoEx19nRu4rjUaD5eVlFBQUoLCwEHq9Hl1dXaceAMYr5C83N9enyD46OoLBYMDm5ibVwRHtRrJC/oQRKV9OC7nkYrFYMs6GW1iJOMTbqpboDcRiMa5cuRITvQG388L3BwsJKgOAoaEhXhcXQGwKjJOTE8zMzKCsrAwDAwMBYm7yQAr38EmlkLf8/PyAbASdTgeFQgEAdFMYSniZSMjoTnNzM1pbW3lZAKUiLMtiZWUFh4eHMdGyEIee5uZmuN1u6nbGnWFP9RG9SHE4HJDJZCgoKKDrSiSbHAFfRCIRioqKUFRUhJaWFrjdbmxubmJ7exvZ2dlYXV2F0Wg8kw1urEL+pFIppFIpPbzxD/kj3Y1Qo16xJBlaVb7DnT44DaGDkeHEs4NB9Ba1tbUxPSFNlQKDOMcUFRUhJycnJexOz1tgkEyP1tZWtLW1nVnMbbFYIJfLUVpaGuA4xXe42QjkNI5Ylc7Pz1P3oKqqqqTkIOzt7WFpaQk9PT24cOFCwn9+uuL1eqFSqXBycoKJiYmYj8nl5OT4ZG74j+j5Z26kU9FotVqpAx33WSIUGOdHr9djZ2cHQ0NDqKqqotqInZ0dqFQqHxvcUM5PsQz545Kfn0/d2LxeL8xmMwwGA1ZWVuByuaiQPZ4hf8Q6XbjPXoHoL0KtM0KBkSGcdhPEo8AgIwKrq6vo7u72SVeOBWSkhs86DK1WS0+I29vb8fzzz/P6eglnLTC4GptgYu5oigu9Xo/5+Xk0NTUFOE6lGtzTuM7OzoDRhMLCQlpsxNu2kWVZrK+vY2dnByMjIygvL4/bz8o03G43Zmdn4fV6MTExEffDhGAjesEEvekQHEmMMerq6tDR0eHzHiGbVj4fNPGZ3d1drKys+IzyBdNGcA0ISNesvLw8ZNfsPCF/p8HVZnR0dNCQP6JZys/Pp/8eS5e/SE7rM41wAm/geoEhjEhlMLEekSKneAaDAePj45BKpTH73oREaUfOAtc1qb+/n4o7U8Va9ywFBsMwUKlU0Ov1AZkm0Yq5d3Z2qBFAKGFsquI/8kLm62UyGXUPIg/vWJ6Wkb+R2WzGxMRExi368cThcEAulyMvLw8jIyNJOeXMz8/3cTvjBkd6PB6f5Gc+jxr6YzKZoFAo0NraipaWloB/FzoYZ4fohEZGRk59TvtrI06zwQ3XNQs2SkWKjfPY4PqH/JlMJhgMBiwuLsLj8UAqldKC4zzdYq6QXeA6kRYYQgcjg4llaB1XbzE1NRXX8Q8+FhihwgPjGWAXS6ItMFwuF+RyObxeb8DfPFoxN8lhGB0dPbcRQCqQk5ODuro61NXV+bgHLS8vw+l0+oxSnWdT6Ha7oVAoUkLLkmqQUT4+CeX9Bb0WiwU6nc4nc4OMUvE5c4PYQXd2dp4qOibPLqHAiBxyCKZWqzE6Ohpxfoi/Da5/10wikdBiI9QBSbBRqlh0N7KzswPue4PBgMPDQ6ysrKCwsJAWGyUlJVG9VyPRDGYakRQYNpsNVVVVCboifpCRBcZpD5Hs7OyYbHyJvV2i8h34VmAQASIprvw3cenYwbBYLJiZmUFJSQkGBweDirnJ7Gqo+8HtdmNubg4ulytjcxj8H95WqxU6nQ4HBwdYWlqim8KqqqqoPOJJqGVhYWGA4F7gfJDTdT6P8nHDzi5evEgzN3Q6Hba2tpCdne2T/MyX+2N/fx+Li4vo7+9HTU1N0M/hrlN8uW6+w7Is1tbWsL+/j7GxsXO58vl3zUwmE/R6PZaWluByuXxsu0Ot6acJxUn3+7whf0TITkL+5ufnwbIsysvLacERbqRRcJAKJJICw2Kx4OLFiwm6In6QkQUGcP1NRzZ8hPNu1FmWhVqtxsrKCrq6uqh3drzhU0fAbDZDLpejsrISfX19QRciPl1vKCItMIiTDdGYnFXMbbPZoFAokJ+fj4mJCWGWGr4uL9wgNrIpzMnJofP15eXlpz74zGYzDbXs7Ozk5QY4VdFqtVAqlSFP1/mIf+YG2RSurKzA6XRGvCmMJ9vb21hfXw9r8ctdT4UCIzwsy9Iu8fj4eExHV7KysmihyrVX5trgkn8PpY04TSh+3pA/f4OEk5MT6PV67O7uYnFxESUlJbTYCNbVExykAom0gyGMSGUw5xmR8nq9WFhYgE6ni5ve4jT40sHY29vDwsICOjo6QqZLp0sHgyvg7+vrC3Ahiqa4MBqNmJubw4ULFwLEmwKv4L8p5AZmud1uKrrkWkqS1HNuYJZAbNjZ2cHq6mpSQx9jARHsVlRU0ORnnU7nY0BACtlEZLkQE4Ld3V2MjY2FHd3hPreEg4nQMAyDxcVFmicUz+IxmA0uWbPm5+fBMIxPyF+okc14hfyVlJSgpKSEdvWIDe7Ozg5EIpFPyF9OTo5QYAQhkmRzIQcjw8nOzj5TcjMRNgLAlStXEm63mewCg2EYrKysYG9vDyMjI6isrAz5+anUwTjtOknonVarDQhMJO1ssuiHKy6IVWqoUCeBQMRisc9JIZmv39nZwcLCAkpKSpCdnQ2TyRRyvEQgergb4HTTCXEFs2RTSNyDSJYLd5Qq1pkbLMtiaWkJOp0OExMTEZ16Ch2MyGAYBkqlEhaLBePj4wl/Vp/WPSCHc8XFxbSQPY8N7llD/iQSiY8WjoT8bW1tYWFhAaWlpcjPz6cTIMJB2HU8Hk9EHQyhwMgQThuRcjgcUX0fk8kEuVyOqqqqU0eC4k0yCwxiSWm323H58uWIHoap3sFwuVxQKBRwu92YmpryOQHzF3OHc4paXV2lhZlglXp2/Ofr7XY7VCoVjEYjRCIRVldXYTKZ0sKqNNmQE2Cj0RjxBjiVycnJQW1tLWpra2nmhk6no5kbxD2oqqrq3MnKZANM8kMiPV0XOhjh8Xq9mJubg9PpxPj4eNKzmIJ1D4hQXCaTQSQSRVzIRhvyF8n65x/y53A4YDAYsL+/D4fDgRdffNEn5C+T77tIOhiCi1SGE82IFLERXV5eRldXFxobG5NWzSerwCDheYWFhZiamop4gUmlDoZ/gcENDBwdHfX5naMRc3s8HiiVSlitVkxOTmbcwhNPPB4PFVfecMMNkEgk1KpUqVSCYRifUap0T32OJR6Ph27SJiYmkhKOmEy4mRsdHR3UPYiER+bm5tL7KtpClry2brc76vwQoYMRGo/HQ7NZxsbGePme9x//DBYeSQqOUOYW8Qr5y8vLQ319PbKzs6FWq9HW1ga9Xo+1tTU4HA6fkL9YB2vynXAaDJZlYbVaz2UkkIoIBQaHSF2kuOMxY2NjST95TkaBQYTNjY2NUYtmU6WD4X+dZESiqakpQCcRjd6CjNRJJBJMTk7y8mGXqjgcDigUCuTk5GBiYoK+tlzLRpLOu729DZVKRVOfq6qqhEIvBMSGOTs7G+Pj48J9i0D3IDJKxc3c8NcEBYN0RbOysjA2Nhb1abD/KbXAK7jdbmoZ738oxFe43YOOjg44HA7a3djY2IBEIvEJ+Qu1uY11yB/DMMjOzqZOfwBoyJ/BYMDa2hry8vJ8Qv7Svej1er1h7yshaC/DiaSDQTaHLMsGjMcki0QWGNyU6mDC5kgQi8UxDTSMF2KxmOopiDtYb28v6uvrfT6P27kIV1wcHR1BoVCgqqoK3d3dwmYghpycnEChUEAqlZ5qDy0SiXzSeR0OB3Q6HT2BzsvLo8VGaWmp8Pd5GZvNBplMhpKSEvT39wuvSxCysrJQXV2N6upqn/l6riaIjFJxT6CJrXdhYSH6+/vPtBnjhuwJc/Gv4HK5IJPJkJubG2Afnkrk5eWhoaEBDQ0NPja4JCdIKpXS7kao7kEsQv6C2dQWFBSgoKDAx6bXYDBgaWkJbrfbxwY3HbuekRQYgotUBhFsEQ7XwSBe7xUVFejr6+PNYpWoAoObTO4fnhcNWVlZcLlcMb662EMWUZVKRe0M/d3BuKdB4YqLw8NDLCwsoK2tDU1NTcJGIIYYDAbMzc1FncOQl5dHT6A9Hg8dpZqdnQUAekoYDzFvqnB0dAS5XC5Y/EaB/3y90+mkJ9DczI3i4mJsbm6ioqLiXOGEQop3IE6nEzMzMzT3Jl2KYq4NLsuysNlsdExvZWUF+fn59N9Djemd1QY3nIsU9/pIjpHBYIBGo8HKygoKCgposZEuhzjhskG8Xi/sdrvQwchkQnUwdnZ2sLS0hM7OTt5tDrOysuB0OuP6M7hOWedNJk8VDQa5RrPZfG4x9+bmJra3tzEwMJBxaZ7xhrhw9fT0nKmjRsjOzvY5gfYX85JchKqqKl50LhOBXq/H3Nwc2tra0NzcnOzLSVlyc3NRX1+P+vp6mrlB7luRSASXy4W9vT1UVVWdaW0lz61UGP9JBHa7HTMzMygrK0tI2G2y4DqeNTc300MS/zG9iooKVFZWhry3QoX8cZ91Ho8nokKDXB+x6W1ubobb7abdF5VKBa/XS216y8vLQ9r08plwGgyLxQIAggYjkwnWwSCOKYeHhxgdHQ0ZdpQs4q1pIOF5sercpIIGw2q1YmZmBgAwMjISUFxEKuYm+Shmsxnj4+MZt8DEE2KVurOzE3MXrmBiXjJKRU7huKNUfDpwiBUkQbqvrw+1tbXJvpy0gWzkDAYD2tvbUV1dHZC5QXQbkd5bQgfjFaxWK2QyGSorK9Hd3Z2W783T8D8kIdbd+/v7WFpaQlFREe0uhLq3TutuEKcrqVQKj8fjk7cRacif/xihwWDA3t4eFhcXUVxcTAuiUDa9fCNcgWGz2QBA6GBkCsFuXP9RIyIYZRgGV65c4e2pZTxHpPb396FSqcKG50UD3zsYBoMBCoUC9fX12Nra8lk4o8m3cDqddNTm0qVLSbdFTCcYhoFKpYLZbMbExETcF+78/Hw0NTWhqakpaC4CKTbKy8tT/hSZ6Ky2trYE++Q4QJLPu7q6qJ7LP3NDp9NBLpdTq1Jyb502picUGNexWCyYmZlBXV1dxgeW+lt3kxA97rpFOhvh3PTIM3t+fh55eXloa2vzeRaeN+SvtbUVLpeLdl92d3chEol8tBt8HlENV2BYrVbk5uam/LMhWjLrtw0DOVlnGAbHx8cxPbWPJ/EoMFiWxcrKCnZ2djA8PBzTsR4+dzDUajWWl5fR09ODhoYGqNVqeq3ROEURwTFp0fP5/kk13G43LfwnJycT3lbn5iIQO0mdTofV1VU4HA6fUapUEzSyLIvl5WVoNBqh4xYHyEnyacnnwe4tvV6P9fV1zM/P+4h5uYJRYUQKOD4+hkwmQ2NjY1Q6rEyBG6JHRkD93fROs8ElYvn8/PwAPUssQ/649/7x8TEMBgPUajUWFxdRUlJCi41QNr3JIJIRqcLCQl5dcyLI3NUoCGRx3tnZwcrKSkxP7eNJrAsMt9uNubk52Gw2TE1Nxdz5gI8dDIZhsLy8jP39fR/rYTJrGo2YW6fTYX5+Hi0tLWhtbeX9/ZNK2Gw2yOVyKtxMduHGtZMkgkbuuEtRUREdd+F7y9/r9dKU48nJSd52bFOV7e1tbGxsYHh4OKKukL9VKRnT0+v1WF1dpWLeqqoqWmCkq9YgHGSMt7W1FS0tLcm+HN7DHQElIXrEhGBzc5OaEBAjAoVCgYKCgqBi+XiF/JHra2trg9PppDa429vbyMrKot0XPoT8RVpgZBoZW2AEe9CTj62urvJWbxGMWBYYZH41Pz8fly9fjktbkm8dDJJG7nA4MDU15WPzRyx1yesbTsytVquxvr6Ovr4+1NTUJOT6MwWz2QyFQsFrNyMiuCTjLsTdRa1WQywW+4xSJbs44kK6QizLRh3yJhAaohXa3d3F6Ojomd33uGN6XDHv/Pw8VlZWAIAKxjPp72cwGDA7O4uOjg40NjYm+3JSEq4NLjEh0Ov1WFlZgd1up90Pu90ecqPM1W6QZ3wsQv5yc3N9QgjNZjMMBgPW19dht9tRVlZGuxsFBQUJfzZEosEQOhgZjNPppHOJw8PDKVNcALErMMhs5lnC86KBTx0Mm82GmZkZWlD5J3OLxWIYjUbk5+eHLLYYhsHS0hJ0Oh3GxsbOvIkQCI5Go4FKpUJ7ezuampqSfTkRkZOTQ0cSuA9t4l1fXl5OC45kuqeQHAZyQsmnwifVYVkWi4uLMBgMmJiYiNkppr+Yl6zVLMvid7/7HUpKSmjnjG/jJLGEdIu7u7vP5SAn8ApisZiOIRkMBtolMBqNNEQvkrR68vFYhvyRzyUhf6SzR7ob3BDCiooKSKXSuK9npHgKp8EQOhgZytHREWQyGRXR8VlMFIzzFhgsy2J7exurq6tnDs+LBr50MIxGI+RyOS5cuBDgNkJmSRsaGrC7u4v19XWaiVBVVeVzQkhGytxuNy5dupRyc/d8htsVOm1uPRUgD+2KigqfUSoyk19cXEzvrURuCC0Wi4/jTqaO2MQDhmHoyNnExETc1gWRSES/d0FBAV796lfTztnm5iZycnLouAvfOmfn4fDwECqVCv39/UK3OMY4HA7MzMygtLQUfX19EIlEaGlpCWqDS2xmz2KDG23IXzDy8/MDQggNBgNWVlbgcrkglUrp2huPsc9IDBYsFkvGOUgBGVxgkAf47u4uFhcX0d7ejpaWFvz+979PiZRpLucpMIgbj16vx8TEBMrKymJ7cUHgQweD/N27u7sD2urcGdKWlha0tLTQDSH5utLSUroZJNaSQ0NDSZ8FTScYhsHKygo0Gk1adYW43vDEPYVsCLe2tpCTk0NPCMvLy+O26TcajZidnUVzc7OgFYoxHo8Hs7Oz8Hg8GB8fj/vIElfkHSxzQ6fTYWlpCS6Xi3bOwm0I+cze3h6Wl5cxODgo5ArFmGDFBSGYDa5er8fBwQGWlpZQWFhIdUElJSUxD/kLR7AQQuLKRnRLpNgoKyuLydoaSYGRiSneQAYXGAzDYGFhAQcHBxgZGUFlZSWAxKVixxKyYee2yiPB6XRCLpeDZdlzh+dFQzI7GMQlZ29vL6jO5jQxN3dD6HQ6odPpsLe3h9XVVWRnZ6OqqgoWiyVtMxESjcfjwfz8POx2e9oLjiUSCZ0vJidwOp0OCwsLNCiLbAhjtVHVaDRQKpXo7u6mVqkCscHlckGhUCArKwtjY2MJOXQ4bZPD7Zx1dXXBarX6bAhJLgLZEKbC2rWzs4PV1dWIxfICkeNwODA9PQ2pVIre3t6Q9wPXBre1tTXAvptlWbrZr6ioCLl2hRKKn8cGl2jiuLolg8GAhYUFGvJH3h9nHVMlKd6hXithRCrDsNvtODk5CRD1hkrz5ivcU4BI299kLCwZNrzEmSnagui8kFNFm82Gy5cv+7zhWZalixq5xtOujSxEFosF3d3dkEgk0Ol0AZkIFRUVaTOOkEhI/kx2djYmJiZSbmTxPHBP4Lq7u2lQ1s7ODhYWFuhsfVVV1ZlFg2q1Gmtra8LpbxwgehbicpaokTPyzAq13nA7Z1wTAr1eD5lMBrFY7LMh5GM3dnNzE1tbWxgdHU1Itz2TIOnn5eXl6OnpiXpt4VosB7PBLSkp8XGmijbk77w2uMG6LwaDAQcHB3QKgThTRVNsR7LvEkakMozCwkJMTk4G3ETB0rz5Drm5wzkZEEh4HhkLS/Sp1VkKovNis9kgk8mQm5sb4I7ln8xNTkiCQfJBDg4OMDo6CqlUCgCoqamhvvVarRYrKytwOp2n6jYEgmOxWCCXy+kJWiZrAvyDsoiVpE6nw8bGBnJzc+m9FUm7n2VZrK2tYW9vL61GzvgCceCrqKg40wbtPJwlaM/fhOC0zI2qqiqfQ7hkwHXiGhsbQ0lJSVKvJ92w2+2Ynp6OWfp5MBtc0t3Y2tryOUgJV8xGa4NL/n+46yNrKzfg0mAwYG5uDizL0s5GeXl5yGe3x+MJ+74TOhgZxmmbyFQckeIWGKFgWRarq6tQq9UxD8+LBvLmj7QgOi8mkwlyuRy1tbUBQtZowvP8x3b8H7qnZSLs7e3RoKDq6mp6+izgC1ncm5qahKCsIHCtJL1eL4xGI3XRYRjGZ5TKv+tDRkJJ8rlw/8UWEvJWX1+P9vb2pNhkAmdP8vbP3LDZbLS7QWbXyb0Vq9n1SCGHOoeHhxgfH8/Ik+B4QpwUq6qq0NXVFZd7Ny8vz0cXZDabodPpggZIhrKZDdfdOKtQ3L/7QkL+dnZ2sLi4iOLiYlpw+HdfIjkotdlsqKuri+i1SicytsAArt+E5NSakIojUuRNFKrAIONBVqsVly9fTuoizV0c4s3e3h4WFhbQ1dUVYG8aTXFht9uhUCggkUgiGtvxF/IS3QZZVInVX3V1taDbwPW/09LSEnp6egS7yQjIysqi3QvyQNTpdHQcoaysjG4Ic3NzMTc3B5fLhYmJiaRa4qYjRCyfzJA3svbHaqypoKAgIHMjWDEbbrb+vPjb/Ca7k5JukOKiuro6YdlCXJtZcg2kmF1bW0Nubi4tNsLZzPp3N2JhgysSiVBaWorS0lJcvHjRJ+RPrVbTkD/S3YjkoNRqtWZkYZzRBUYwUnFECgjdebFarZDL5cjNzcXU1FTSZ9pJ9yierzM59drZ2fER8ROiSeY2m82YnZ1FdXU1urq6znR6l5ubS0+fPR4PdbbIdN0GGX0gfydBtBk93Adie3s77HY7HaVaXV2FSCSCRCJBT09P0t/76YZWq4VSqURXV1dSxfLn7WCEwn92/fj42Ge2vrS0lG4IY2mxTBwOj4+P42rzm6lYrVbMzMygtrYWHR0dSTvk4hazpDOr1+uxuLhIXc/I/RXK7CNeNrj+IX9HR0cwGAzY3NyESqVCfn4+GIahad3BXkehwBAAkJodDOD0AsNgMEChUKC+vh6dnZ28mWmPp5OUx+PB3NwcLBZLQLcmGjE3ABwcHFAb41gFvGVnZ6OmpibjdRtkA0HGdjJxAY4H+fn5aGxsRHl5OWQyGfLy8pCfnw+lUgkAdK6er0LeVGF/fx+Li4sYGBhIej4L16Y2nnCL2ba2NqoL0uv1NOSM3F/nCTljGAbz8/Ow2WwYHx8Xum4xxmq1Ynp6GhcuXEjKSN9p+HdmievZ4eEhFWKTYqO0tDQqG9xYhfyRUUJymLO+vg6TyYTp6WmaOVNSUoLCwkKqFYqVyPuf//mf8dWvfhWHh4cYGhrCt771LUxOTp76+Q899BD+5m/+BltbW+jo6MD999+Pm2+++dzXESkZ/XQJNiKVnZ0Np9OZpCs6O/4FBjc8r6enBw0NDUm8ukDilYVht9shk8mQk5ODy5cv+2zQuScaQHgxNzlZHxwcDOiAxIpM1W243W4oFAowDIPJyUlhAxFjjo6OIJfLfTQBxNnFf/aZPNDT2Qo41mxvb2NjY4M3Xbd4djBC4a8LImn15PSZuPJEk7nh9XoxOzsLt9uNsbGxtD5kSQYWiwUzMzOor69HW1sbb4oLf4K5nhGh+OzsLBVik/vrLDa45MDxPCF/xcXFAICenh6YzWYYDAY89thj+NznPoeRkRG88Y1vhNFoPHeB8dOf/hT33nsvHnjgAVy6dAnf+MY3cOONN2J5eTnoAceLL76Id7/73bjvvvtw66234sEHH8Ttt98OmUyG/v7+c11LpIhY/x12BuF2uwNO0be2tmAymTAyMpKkqzobL774Ii5evIja2loq6NTpdBgeHqZOR3zi+eefx8DAQEwfzmazGTKZDDU1Nejp6TlVzB1u8fB6vbQ1Pzw8nLSTda5uw2g0po1uw2azQS6XUyvPTBoJSwRkVj5c143MPut0OphMJp+QrFS+v+IJ14lrdHSUN25GP/3pT/H+978fr3vd6/DLX/4y2ZdDT591Oh30ej2Ojo5QVFREdUGn2YB6PB6aoTAyMiJ02GJMqhQX4eCO6un1ehwfH/vY4EZrM8sN+eNuiSPpbmxsbMDpdKKnp8fne6pUKvz85z/HM888g+npadTX1+POO+/EzTffjNe85jVRH6pdunQJExMT+Pa3v01/RmNjIz72sY/hU5/6VMDn33XXXbBarXjiiSfoxy5fvozh4WE88MADUf3ssyK8e/3Izs5O2REphmFoeB7DMAkNz4uWWHcwiPVuZ2cnmpqafBaXaMTcTqcTCoUCYrEYk5OTST0989dtGI1GaLXalNZtkJP1urq6hIkKMwmScNzX14eampqQn8udfSangzqdDnK5nGYipNr9FU/8Bcd86igmakQqUoKl1ZP7S61WB83ccLvdkMlkyM7OxsjIiHDPxZiTkxPMzMygsbERbW1tyb6cc+E/qkeE2MHur/Ly8pDas/OG/AUTeYvFYgwMDGBgYACf+cxn0NPTgz//8z/Hzs4O3v/+98NkMuGNb3wjbrnlFtx0001obGwM+fu6XC7MzMzg05/+tM/PeNOb3oSXXnop6Ne89NJLuPfee30+duONN+Kxxx4L+bNiCT9WoySRLja1wPXrPjk5wcrKCqRSKfr7+3m9QMdKg0FOFLe3t4Na70ZTXJycnEAul6O8vJx3GQxcoWUw3UZ5eTmqq6upaxAf0Wg0NH8lVnoWgeuwLIvNzU36Poi2M8i1aSQ2ksSi1H+Uiq+HFvGEaAKsVisvBcfJGpGKFIlE4pO5Qe4vMqpXVlZGhbAjIyO8WnvTAVJcEAvwdMNfiB3s/iIFR6iA0rOE/Hm93rDmGQ6HA295y1swOTkJlmWhVCrxy1/+Ev/7f/9vfPjDH8bi4iI6OjpO/Xq9Xg+v1xtwaFRTU4OlpaWgX3N4eBj08w8PD0NeayzJ6AIjGKkq8na73dje3kZ7eztaW1t5fzIciw4GyaU4Pj4+VcwdqVMUcYMhVpN8fv0i0W2QUSo+nLKyLAu1Wo319XX09/cnXRCbbpCTdb1ej/HxcToTfFa4NpLc+4sILcmoS1VVVchE3nSBWHx7PB6Mj4/zUhMQa5vaeOJ/f5lMJszOzkIkEsFkMuEPf/iDz6ieUGycD5LR0tzcjNbW1mRfTtzxv7+Iqx4pOCQSCe3MlpeXR2WDGyzkz+VyQSKR0H1GMKxWK12XRSIR7W586lOfgtlsTtvQU/6vRgkm1WxqyQn+8fExamtrU+Z04rwdDIfDAZlMhqysLExNTYUUc4cqLogYfmNjI6KxEr4RKm9jY2OD6jZI2nOiN4MMw2BlZQUajUZIj44DXq+Xuu1MTk7G5WS9sLAQhYWFaGlp8Rl12d7eRnZ2Nt0MhntYpyIulwtyuRzZ2dkYGxvj7Qae7x2M07Db7VCpVKiqqkJvby+8Xi8V8s7NzYFhGJ9RKj4Wd3zm6OgIMpksqRktyYa46jU2NlIbXIPBgKWlpahtcAHf7oZGo4HRaMSFCxdOFYq73W44nc5TtZxlZWVhf4fKykpkZWVBo9H4fFyj0aC2tjbo19TW1kb1+fGAn6tlEkmlESmuHWtNTU1KucCcp4NBFk3yUAom5iZCrVCnXwzD0Jnq8fFx3gg2zwNXt0Ee1lqtFrOzswASq9vwTz5PpfszFXC5XFAoFBCJRBGFP8YC/1EXk8kEnU5HH9bE1aWqqoq3o3qRQg4xiBkBn0/SU7HAIDkMJF9IJBL5WHgHC5AkmRvEVS/du2fngTwnL168iObm5mRfDi/g2uB2dXVRG1yNRoPl5WUUFBTQYiNcYr3RaMTCwgL6+/tRVVV1qg3u8fExAJyrsyyRSDA2NoZnnnkGt99+O4Dr+5dnnnkGH/3oR4N+zdTUFJ555hl84hOfoB97+umnMTU1debriJaMLjBO02CkwoiUzWaDTCZDbm4uLl++jI2NjZQpjICzdzAODg6gVCrR0dGB5ubmM4u5XS4XZmdn4fV643bym2yysrICdBs6nS4hug1iNpCdnZ2wzW8mYbfbqRNXsvRWYrGYJtqSh7VOp8P+/j6WlpZQXFxMH+axDGBLBFarFTKZDBUVFejp6eH9tZNnVqoUGEQT0NDQcKqbkX+AJMncIN1ZMuoSSeJzpmE2myGXy9HW1ibo3U4hmA0uCfkjifXl5eX0QI77jDQYDJibm/OZejgt5O/pp58GgHPvz+699168973vxfj4OCYnJ/GNb3wDVqsV99xzDwDg7rvvRn19Pe677z4AwF/8xV/gta99Lb7+9a/jlltuwU9+8hNMT0/je9/73rmuIxoyusAIRnZ2ts/cPh8h4XkXLlygydJZWVkpld8RbQeD5FJsbm5iaGgoYI6f27kIV1yQZPPi4mLei+FjBVe30dHREVfdhsVigVwuh1Qq5Z1YPh04OTmBTCZDdXU1uru7ebH5DeYaRCxKNzc36WaQBLDx+Z4gM+vcDBG+k0odDHKy3tLSEpUmwD9zg5v47Ha76ahLOnTPzgMpLtrb28O6Ewm8Qk5OTkD3TK/XY2dnByqVitrgSiQSrKysoLe3N+i4EXeU6vnnn8df/uVf4ktf+hIqKirOdX133XUXdDodPv/5z+Pw8BDDw8P49a9/TQsc4p5FuHLlCh588EF87nOfw2c+8xl0dHTgscceS1gGBiAUGAGQGVuv18u7hyDLstjZ2cHy8nJAeF4qjXYB0XUwyJz50dERLl++7NNqjFbMTU4eiFVfKmweYk08dRvk9SVuJZn4+sYTo9GI2dlZtLS08NqMQCKRoL6+HvX19TSATafTQaVSwePx0LT6cAFZiYa8vqk2s54qHQyj0QiFQnFuJzn/xGeLxQK9Xk+7Z5FkbqQjJpMJcrkcHR0dQnFxDvxtcF0uF72/TCYTsrKyYDAYIBKJUFFREbRD/8ILL+Cd73wnvvnNb+IDH/hATK7rox/96KkjUdeuXQv42J133ok777wzJj/7LGR0gXHaiBSAiKzHEgnRC2g0GoyPjweE58UrGTteRHq9DocDcrkcIpEIly9f9jmZikbMDQA7OztYWVlBT08PLly4cP5fIk2IlW5jb28PS0tLwusbJw4PD6FSqVLu9c3KyqJzzd3d3Tg5OYFOp8POzg4WFhZ4M1dPnOS6urpQX1+flGs4K6ngIkWE27F+fUUiEYqLi1FcXEy7Z8Q1iJuJQIwI+PwanQdSvHV2dvocPgqcH4lEgoKCAhwfH6O7uxtFRUW0O6tUKvHzn/8cpaWluHr1KkZHR/HHP/4Rd955J7785S/jAx/4QMYUuP6k5zvtHBDlP590GMTJxOv1YmpqKqhYNhU7GG63O+TnkFZ6RUUF+vv7zyXmXllZweHhIcbGxiJybchUuLoNlmVhNpsDdBuk4CDFHhlf29nZwcjISEzT2QWus729jfX1dQwNDaGysjLZl3NmRCIRSkpKUFJSgra2toC5+tzcXJ/uWaK6yCSgMFVtlMkhC187GFqtFvPz8+jt7UVdXV1cf5ZEIgnIRNDpdFhdXYXdbvcZpUoX4wlSXKRicZwKkIBYbmeIjBvb7XYsLS3h8ccfx7e//W0UFRXBYrHg7rvvxvve976MLS4AocAICp+sask8cFlZGQYGBk59gKRagRGug3F4eIj5+Xm0tbUF5HpEMxLldrsxPz8Ph8OBS5cupc0DJRGIRKKgug0yhkBmUo+OjnBycoKJiYlTrfgEzgbLslhZWcHBwUFa2vz6z9UTi1IisuSOUsWro7y1tYXNzc0zBRTyBb4leXM5ODjAwsICBgYGEl68cTMRuK5B5NCkoKCA3l+pmrlhMBgwOzuL7u7ulOpspgpkD3bx4sWgY2f5+fl0dOmll16iXYxnnnkGFRUVeP3rX49bbrkFN998c8rECMQK/q1GCeS0jSlfNutkk33x4sWw8+x8ueZIOU2DwbIsNjY2sLGxgcHBwYBcimicoojTTl5eHiYnJ3n58E0Vguk2Dg8Psbm5Cbfbjfz8fOzv7yctbyMdYRgGKpUKR0dHmJycREFBQbIvKa74d8+IRenW1hZUKhXKyspodyMWrwXJENrb28PY2FhK21TzVeS9u7uLlZUVDA8Pn1vkGgtIpktzczN1DdLpdJidnQXLsnSUL54FbSwhY2c9PT1x7wxlIsRQo7W1NazVr0qlwl133YVPfepT+OxnPwsAWF5expNPPomf/exnuPfee9HW1oYPfehD+PjHP56Iy086wo4rCMm2qiUPvq2traCb7GCkWoERrIPh9XqhVCphMplw6dKlgAc+12c6XHFB0mFra2vR2dmZkidTfMbr9WJ3dxdlZWXo7e2lYwjJyNtIR7jp0ZOTk7wSQicCf4tSksZLRl2IX/1ZC1qSfm4wGDAxMcGLxPvzQJ5XfFrnSIDpyMhIgGaQD/i7Bh0dHUGv19OCtrS0lHY3+Ji5odPpMD8/LxQXccJisWBmZgZNTU1hDR+WlpZw66234kMf+hA++9nP0nulu7sb3d3duPfee3F8fIzf/va3vHqPxhuhwAhCMkekSDjZ8fFxgGNSKFKtwPDvYDidTshkMgDXA2L8xdykcwGEF3Pv7+9jcXERnZ2dgpNGHCDzqLW1tTQgK5huY3V1FfPz80F1GwKnQ4wNcnNzeZ0enUi4abwej4emiZOClhQbFRUVYV8vhmEwPz8Pq9WKiYmJtMjA4ZPIm2VZbG5uQq1WY3R0NCXG+kQiEcrKylBWVkYzN4jN8vr6OnJzc+k9xgebZZ1OR3MYEpnMnCmQEMjGxsawY02rq6u49dZb8d73vhdf+MIXTt2blJSU4I477ojH5fKW5K9GSSTUiFQyOhg2mw1yuRw5OTmYmpqK6tQy1QoMbgeDzDhKpdKAXIpoxNyk87O7u8ublny6QZx2TrOZjES3QYoNPp4KJhsS8CZkiJyOf9ozCZBcX1/H/Pw8pFIpvcf8NVfcztD4+HjadIb4MiJF1uD9/X2MjY2dK704meTl5dGClpu5wbVZJqNUiT40IYL5/v7+iKYbBKLDarVienoa9fX1YYuLzc1N3HrrrXjnO9+JL3/5y8J67UdGFxinkYwOhtFohFwuR11dHbq7u6O+UVOtwCAdDI1Gg7m5uaA6k2jE3GS86uTkBJOTkyk/8sA3WJaFWq3G+vp6xE478czbSEfMZjMUCkXIdGMBX7gnzx0dHbDZbPQeW1lZQWFhIb3H8vLyoFAokJ2dnXadIT6IvFmWxfLyMrRaLcbHx9NmDeZmbnR3d8NisfiElBYXF9PuRnFxcVzftxqNBkqlMimC+UzAZrNhZmYGdXV1YddgtVqNm2++GW9729vwD//wD0JxEYT0WWHPiEgkoqfjhERv1tVqNZaXl9Hd3X3mkZ6srCy6IU+FG10kEsFut2Nubg4DAwMBbd5oxNwOhwMKhQJZWVkZOa8eb8jGQaPRnMvJKFjehqDbuA7pDAkBWeejoKAAzc3NVMRL7jGZTAav14vc3FxeBxSelWTb1LIsi4WFBZhMJkxMTKStWx83c+PixYs0c0On02F7exvZ2dm0sxHrdUyj0UClUmFwcBBVVVUx+74C17Hb7ZiZmUFNTQ06OjrCjmHfcssteMtb3oJvf/vbKbHnSgYZX2AEIzs7OyEjUgzDYGlpiVpQnscikSxkqVBgMAwDtVoNt9uNqampgA1rNGLu4+NjKBQKVFRUoKenh/e/e6rh9XoxNzcHu92OycnJmG0cTsvbyETdBnHaSdUMBr6Sk5OD2tpaFBcXw2QyoaysDAUFBVhdXYVSqfTJQ0h1HUYyk7wZhoFSqYTFYsH4+HjKv5bR4J+5YTKZoNfraW4QGderrKw819pJQjaF4iI+OBwOzMzMoLKyEp2dnSH3HIeHh7jlllvwqle9Cg888ICw5wiBUGAEIREdDJfLBYVCAbfbjStXrpx740YeLB6Ph9etf5fLBZlMBrfbjZycHJ/iIloxNznRuXjxIpqbm9PuVDLZOJ1OyOVyZGdnY2JiIm62jZmq2yCWzGq1mrdOO6kO0XfV19ejvb0dIpEInZ2ddJTq8PAQy8vLKCoqovdYvMdc4kGyRN7kAMLpdKaVpuUsiMViVFRUoKKiwidzQ6PRYHl5GYWFhbSgLS0tjfgeOzg4wOLiYsqHbPIVh8OB6elplJeXo7u7O+TfRavV4tZbb8Xo6Ci+//3vZ1ynPVr4uxNNEKeNSDmdzrj9TOKtXFJSgtHR0Zg8FMhmPFi2BF8gv3dpaSm6u7sxPT1N/81fzC0SiU59o7MsS8OxhFPf+GCxWCCXyxMuNg6m29Dr9dBqtWml22AYBouLizAajUJAYZwwGo2YnZ1Fa2urj82kSCSieQgtLS10zEWv1/uMuVRVVaG8vDwlNhHcQ5lE/kyFQgGv14uxsbGUyI1IJP6ZGyREUqFQAIDPKNVprx05ZBkaGhJMS+KA0+nEzMwMpFIpenp6Qj5PDAYDbrvtNvT09OBHP/oRrw9y+YLwCgUhniJvImpubW2NuZCTz0JvrVaLubk5tLS0oK2tDTabjV5rNGJuhmF8Zn1T1aWEzxgMBszNzaGpqSlswGO8yc3NRX19Perr64PqNiorK1FdXZ1Sug1y6utwONLGJpVvEE1LJOnGwcZcdDodlpaW4HK5fNLE+Tqul2iRt9vthkKhgEgkitkhWTpDxvVqa2t9nM82NzehVCpRVlZGi9qCggKIRCKhuIgzLpcLMzMzKC0tRW9vb9hcratXr6KlpQU//vGPhWI6QoRVIQjxsKnlJlQHEzXHAj4WGKTbsLa2hv7+fhoIxBWlR1pcuFwuzM7OgmEYTE5O8vZhn8qQDJGenp6wG7NEkw66DTIaKRaLMT4+Ljyo4sDe3h6Wl5fP1N30H3OxWCzQ6/XUMaikpIRuBIuKinjTQUukTS0Zc83NzcXg4GDKFPZ8wd/5jIRIcjM38vLycHR0JBQXcYIUF0VFRWGLi+PjY7z97W9HTU0NHnrooYweA4yWjC8wgt1Ysd6oezweKJVKmM3mqMLzooVvBQbpNuh0OkxOTvroLUgr3+12QyQShS0uLBYLFAoFSkpK0NfXJzzUYgzLslhfX8fOzg5GRkbOZTiQCLi6jc7OTlitVmi1Wl7rNux2O2QyGYqLi4V7OE6Q0cnh4eFz38NcxyDuuB45eZZIJPQeS3b4WqIKDDJSUlhYiIGBAUHgGgO4IZJerxcrKyvY29tDdnY25ubmfDpowub2/LjdbshkMhQUFKC/vz/kPWyxWHDHHXegpKQEjz76KG8PrvhKxhcYwYjliBTZVGRnZ+PKlStxXSD4VGC4XC7I5XJ4vV5MTU35jIGwLEsLCoVCQU+lTxsV0ev1mJ+f58XITjriP3aWinqAwsJCtLa2BtVt5Obmorq6Oqm6jePjY8jlctTU1ND0c4HYQQLe9vb2MDY2hpKSkpj/DP9xvWDha8naCCZC5E1sPMvKyoQQyDixv7+Pw8NDjI+Po7S0FCcnJ9Dr9djZ2cHCwgLtoFVWVqakGUGyIcVFXl5e2ALZarXiT/7kT5CTk4PHH388ba2X44lQYAQhViNSJpOJbioSYaHKlwLDYrFgZmYGJSUlGBgY8HnoccXcV65cgU6ng1arxcrKCoqLi1FVVYXq6moa0rSzs4O1tTX09PTQ8SqB2OF2uzE7Owuv15s2Y2d8020QTUtra6vgdhYHWJbF4uIiDAYDJiYmEhLw5h++dnJyAp1OB7VajYWFBZSWltJ/JzP18STeHQySMF9ZWRnWaUfgbJAg05GREZSVlQEASkpKUFJSgosXL9KDE71ej62trZQ0I0gmHo8HcrkcEokEg4ODIfdjdrsd73rXu+D1evHrX/86bUIjE41QYAQhFh2MnZ0dLC0toaurC01NTTG6stDwocAgG7nm5mZqC0nghueJRCKfUCzi5KLVarG5uYnc3FxkZWXB4XAIFp5xwm63Qy6Xo6CgACMjI2n5gPLXbRwdHUGr1SZMt3FwcICFhQX09vYKBXIc8Hq9UCqVsFqtSRPMi0QiuhFsa2uDw+Ggo1Rkpp7rfBaPg6Z4irzJgVFdXV3YADKBs7G9vY2NjQ2Mjo6eGmTKPTjhZm4sLy/D6XTSXJfzZm6kI6S4yMrKCltcOJ1OvOc974HFYsFvfvMbwUjmHGR8gRFrDQY3PG90dDShAi2xWJy0AoNlWajVaqysrKCvry9AIBwumZvr5OJwOCCXy+FwOAAAc3NztLNRXl4utOZjwNHRERQKRUaN7HDFlUS3Ea+8DZZl6aZheHhYEGrGAY/HQ7tvfMpgyMvLC5pYPz8/D4Zh6CawsrIyZiL/eNnUkhyRxsZGYTw1ThDdUKjiwh+uGQE314WbuUHG9aLJ3EhHiJ2ySCTC8PBwyIM0l8uFu+++G1qtFr/97W8j/nsIBCfjC4xgkA4Gy7JRvTGJy5HT6cTU1BQKCgrieJWBJKuDQTz9NRoNJiYmaHuXEK644GKz2aBQKJCfn4+JiQmIxWKYzWZotVosLi7C7Xb7jLgILjzRQyw829vbE9Zd4yPcLASugNdft1FaWhrVxo1lWSwvL0Oj0WB8fDwueoBMh2i8srOzeW2T6t9BOz4+hk6nw9bWFlQqFcrKynxGqc5KPJK8zWYz5HJ5QI6IQOzY3NzE1tbWuXRD/rkuJHNDp9NFlbmRjpDigmVZjI6Ohnx/uN1uvP/978f29jaeffZZ3hudpAL8XJWTDLkJvV5vxA+uk5MTyOVyFBUV4fLly0l54CWjwOAmkk9NTfm0ZqNN5jYajZibm8OFCxd8WvHl5eUoLy9HV1cXTk5O6BiVUqmkIy7V1dVpoR+IJ6TLtL6+LgQU+hEr3YbX64VKpcLJyQkmJiYSfsiQCTgcDshkMhQVFYV1geETIpEIpaWlKC0tRXt7O+x2O3Q6HbVaLigooMVGtKfOsRZ5GwwGzM7OoqOjA42NjTH5ngK+bGxsQK1WY3x8PKZjONzMDYZhaFHLzdwg3Y101hZ4vV7a4QxXXHg8Hvz3//7fsbS0hGvXrsU1Mf073/kOvvOd72BrawsA0NfXh89//vO46aabTv2ahx56CH/zN3+Dra0tdHR04P7778fNN98ct2uMFRlfYJw2IgVcv+kiWbBJiFww3UEiSXSBYbFY6IPe/xSRm3EBhE7mBq571xPNSkNDQ9DP4c46t7e307bw4eEhlpeX6YgLVyQucB3uqfrY2JjQ+g3BWXUbRDDPMAwmJiZ4M7KTThCxcUVFRdjkXb6Tn5+PpqYmNDU1wePxBD11rqqqQkVFRdjnEFlnY9HBIONckYQUCpwNYgk+NjYW1xl/sVgcNHODFLX5+fn0PouXPigZMAyDubk5uN1ujI2NhXz/eL1efOQjH4FCocC1a9fifvDW0NCAL3/5y+jo6ADLsvi3f/s3XL16FXK5HH19fQGf/+KLL+Ld73437rvvPtx666148MEHcfvtt0Mmk6G/vz+u13peRCzLssm+iGTCMAzcbnfAx3/zm9/ghhtuCLlRTUR4XjQsLy/D4/EEvUljjV6vh0KhQGNjIzo7O4OKucmtFWrRIvaSu7u7GBoaOnNb0uVyUUcqo9GI/Px8WmyUlJSk9EbkvJDkaLvdjpGREUEAeA6IbkOr1eL4+JgWtSUlJVheXkZ+fr4QPhYnjo6OIJfL0dDQgLa2trR9T5MQSbIRtNlsVMBbVVUV9P37pje9CS+99BIefPBBXL169cw/+/DwECqVCv39/aipqTnPryEQBLJn2NnZwfj4eFItwT0eD7Va1ul0YBiGHp6kcuYGwzCYn5+H3W7H2NhYyJEwhmHw8Y9/HL/73e/w3HPPJa1bV15ejq9+9av4wAc+EPBvd911F6xWK5544gn6scuXL2N4eBgPPPBAIi8zajK+g3Ea4axqvV4v5ufnYTabcenSJV7MWWdlZcHpdMb956jVaiwvL6O3txf19fU+/xaN3oIEEFqtVkxOTp6r6yCRSOiICzkN1Gq1kMlk1FKyuro66YFYicbpdNJZ9YmJiYyav40HwXQbBwcHWFtbQ1ZWFioqKnB8fBy1bkMgNEajEQqFAm1tbWhubk725cQVbohkR0cH7dQSO28i4CWFrUgkiolNLTE7GBwcRFVVVax+HYGXIWGme3t7SS8ugOvjdNxOLbFa9s/c4FtqfSgYhoFSqYTNZsP4+HjY4uKTn/wknnvuuaQVF16vFw899BCsViumpqaCfs5LL72Ee++91+djN954Ix577LEEXOH5yPgC47Q3TSirWmLvmZWVhampKd7M/sd7RIo4ZJEgIH/r2GiKC+IUJZFIMDk5GdONb3Z2NmpqalBTU0Pt/LRaLVQqFbxer888PV/FobHAYrFALpdDKpUKwVhxIDc3FwUFBTg5OUFLSwtKSkqg1+t9dBuRjrgInI5Go4FSqURPT09Gjuxw7bzdbjfNQpDJZBCLxaisrKSOe2ctMHZ2drC6uhqTBHSBQEinfn9/H+Pj47wb4fW3Wg6WuUE6G3zN3GBZFiqVClarNaLOxac//Wn88pe/xLVr1xJuYjA/P4+pqSk4HA4UFRXhZz/7GXp7e4N+7uHhYUA3saamBoeHh4m41HMhPPVO4bTNOgnPq66u5t2mLZ4FhtvthkKhgNPpxOXLl33Eq0TMTTQX4YoLYpFKQqri+Rpy7fy6u7up4G19fd1HJB6vHIRkQcLdhPTz+KHRaKBSqdDZ2Ul1QzU1NVS3odPpsLa2ltb3WbzZ29vD8vIyBgYGBFMCXBfw1tXVoa6uDgzDwGw20zEq4Lrl6e7uLiorKyPOBOHapPo7AAqcH5Zlsbq6Sg/m+FZcBCNY5oZOp8PS0hJcLpfPKFUysmf8IcXFyckJxsbGQo53MQyDv/u7v8MjjzyC5557Dm1tbQm80ut0dXVBoVDg6OgIDz/8MN773vfi+eefP7XISFWEAuMUgo1I7e7uYnFxEZ2dnWhqauLdpi1eBQYRVhYUFAQ4ZPmLucMVF4eHh1hYWEBbW1vCX0N/Fxf/HASSvltdXZ3S7j/7+/tYXFzM2BPfREBOfIO5cXHzNjo6OuKat5HOkI2vcKoeHLFYTB32yCavtLQUBwcHWFpaQlFREb3PiouLA+4zMrKzu7t7LptUgdNhWRYrKyvUsjoVnyvcQ7quri5YrVY6Grq0tJT0zA2WZbGwsICjoyOMj4+HPMBhWRb33Xcf/v3f/x3PPfccurq6EnilryCRSNDe3g4AGBsbwx//+Ed885vfxHe/+92Az62trYVGo/H5mEajSbrmNxIyvsCIZESKYRgsLy9jf38/4eF50RCPAsNgMEChUKC+vj4gkC1aMTfx/B4YGODFjK//PD2Zc15bW6OLZnV1ddCHMx8hAkK1Wi2Eu8UJ7qYs0hNf7n1GzAi4eRvkPhN0G9fhjpMIG9/IIOt+fX09JiYm4HK5qHh3e3s7YMRFLBZjZWWFnqonWw+QjhDnPp1Ol7LFhT8ikQhFRUUoKiqimRtklEoul0MkEiV0NJRlWSwtLcFkMkVUXHzta1/Dd7/7XTz77LO86hYwDHOqfnZqagrPPPMMPvGJT9CPPf3006dqNvhExhcYp0E6GNzRoGSE50VDVlYW7STEgp2dHSwtLaGnpyfAOjYavYXX68XCwgLMZjMmJibiast3VnJzc2n6Lgkq0mq1mJ6eRk5ODt0E8tXKj2EYLCwswGQyYWJiQtgwxAESKGk0GjExMXGmUQeuGcFpeRuZrNvgvsapMk7CB/xF3hKJBBcuXMCFCxcCRlzcbjdycnLg8XgwMjIirBVxgGx89Xo9xsfH09a5z39k7+joCHq9Huvr65ifn4dUKqVrWqz3TqSAI69xqFEtlmXxT//0T/jmN7+Jp59+GoODgzG9lmj49Kc/jZtuuglNTU04OTnBgw8+iGvXruGpp54CANx9992or6/HfffdBwD4i7/4C7z2ta/F17/+ddxyyy34yU9+gunpaXzve99L2u8QKZn3BAuCSCSip/CE7Oxs2O12vPTSSygsLExaeF40hHO+ihSyOJITRP/xBG7nIlxx4XQ66eZpcnIyJebP/YOKjEYjtFot5ufnwbJsxKFriYLkL3g8npR5jVMNj8eDubk5OJ1OTExMxGTuOFjeRibrNrxeL3WVi9VrnCmESvLmjrh0dHRgdnYWx8fHyM/Px/T0NB3Zq6ysTBm3ID7DsqxPkZyuxYU/YrE4wP2MdDdinblBRs9IdyjUa8yyLL7zne/g/vvvx1NPPYWxsbEz/9xYoNVqcffdd+Pg4AClpaUYHBzEU089hTe/+c0Arrt0cl+bK1eu4MEHH8TnPvc5fOYzn0FHRwcee+wx3mdgAEIOBoDrGQr+L8P09DSMRiNaWlp8UqX5zNHREWZmZvCGN7zhzN/D4/FAoVBQD2n/Uweit4ikc3FycgKFQoGysjL09vbyYjN+HribQK1WC4fDgYqKClRXVyfNN5w4mgn5C/HD5XJRq9/BwcGEWP0S3YZOp8PR0VHa6zY8Hg9N3R0eHk5ZD/5k0dvbi+3tbVy7dg0TExNBP4fkA9hsNoyOjiI3N5e6Bel0OhgMBkgkEnqfZZqldywgegAysiMUydchmRs6nQ56vR4Mw6CiogKVlZVRPzvJCOXBwUHY0TOWZfH9738ff/M3f4Mnn3wSN9xwQyx+HYEIEQoM+BYYRCuwurqK8vLyUxdrPmKxWPDSSy/RSjhabDYbZDIZ8vLyMDQ05LORijaZm6TBtrS0oLW1Ne02RCzL+oSunZycoKysjI5SJeLUirhx1dTUBOhjBGIDeU+Ulpair68vKRsurm7DYDBQ3Ua6pO9yC7ihoSHed4r5SFdXF3Z3d/H73/8eo6OjAf/u9XoxOzsLt9uNkZGRoBs6r9frswn0eDx0A5jKwWuJghQXZrMZY2NjQnFxCizL4vj4mBa2Foslqi7a2toazRIJF4T87//+7/jrv/5r/OIXv8DrXve6OPw2AqEQVnK8MiJFWvQmkwn19fUBXQ2+Q0TeLMtGvdk0Go2Qy+W4cOECurq6fDYt0Yq51Wo11tfX0dvbmxJOB2eBK3ZrbW2Fw+Ggxcbq6ip1cKmuro7L2IFWq4VSqcyI4LFkQZKjL1y4kNQu5mm6jbm5OQCprduw2+2QyWQoLi5Gf39/yhdLySLUiBTpSrMsi7GxsVPvERJIWlVV5RO8plarsbCwQF32SBdN4BWITerR0ZFQXISB6+bY1tYGh8NBR6k2NjYgkUhoUeufubGxsYHd3d2Iiosf//jH+OQnP4nHH39cKC6ShNDBwPUZdnJSKRaLMTIygv39fZjNZoyMjCT78iLG5XLh2WefxZvf/OaoRmWI/W5XVxeampp8/o10Lrxeb9iRKBLEp9PpMDw8jNLS0jP/LqkMcdbQarU+YwdEJH7ejer29jbW19eDWqQKxAa9Xo+5uTleF3DBRvZSSbdhtVoxMzODyspK9PT0CB24c9DS0gKdTof//M//9JnNdrvdNBR2eHj4zCOU5ABFr9fDaDQiLy8vZvP0qQ7DMD4ZDHx/3/EZr9cLk8lEuxvczA273R5xCvrDDz+MD3/4w3jooYdw0003JejqBfxJreOuOGE2m+mDjoxBhEry5ivk4eH1eiN6kBAXhr29vaD2u9E4RbndbszNzcHtduPSpUsZfYLDddYgYwdarZaK3UmxEW0iKvl7aTQajI2NZWwBF29IjkhfXx+vO3Cn5W0Qf/ri4mJUV1fzUrdBukMNDQ1oa2vj1bWlIv4uUsD1A6eZmRnk5+djYGDgXPqsvLw8NDY2orGx0Weefn5+HgzD+HTREqFR4gsMw0CpVMJisQjFRQzIysqi3QuSuaHT6bC1tQW73Y6CggIcHh6iqqoKJSUlQdeNn//85/jQhz6EH//4x0JxkWSEAgPXVfutra1obm6mN2w8U7HjBTlFiuS6iajSarXi8uXLAe3GaMTcVqsVCoUChYWFwgy1H/5jB2azGVqtFsvLy3A6ndSRqrKyMuSD2ev1Ym5uDna7HZOTkxnjTJJIWJbF1tYWtra2MDIyknLhbpHkbfDhxNlgMGB2dpbX3aFUg6z5ZO11OByQyWQoKiqK+ehZdnZ2gPuZXq/H5uYmlEplXK1J+QRXND8+Pi5oVGIMGUM2Go1wu90YHR2l65pMJoNIJMKPf/xjXLlyBbfddhukUimefPJJfOADH8CPfvQj3Hbbbcn+FTIeYUQK10/f/fMjyCx9qrkOkACWUC1Eu92OmZkZ5ObmYnh4OEDMTToXQHgxt9FoxOzsLBoaGtDe3i6cREYIy7KwWCzQarVU6CaVSml3g9sBcjqdPiLYTDohTBTEmlmr1WJ0dJSXWS1nhdtF0+v11Go5GboNjUYDpVIppMzHmJqaGlgsFszPz6Ourg4zMzOQSqXo7e1N6Jpst9tpYWsymVBQUEAL22SkPMcLbnExNjYmFBdxYmdnB2traxgdHfXp2DMMA41Ggy9+8Yt47rnnsL+/j4sXL2Jrawv333+/TyidQPIQCgxcP833P/U3GAxQqVR4zWtek6SrOhvPPPMMxsfHTx2fMZlMkMvlqK2tRXd395nF3MB17cby8rKwWYgB5MGs1WphNptRXFyMqqoqFBUVYWlpCeXl5ejt7c3oWed4QcwdLBYLRkdH07o7xNVt6HQ62O32hOk2dnd3sbKygoGBAVRVVcXt52QiFRUVcDgcmJmZgVarRXV1ddKd5TweDzUk0Ov1AFLbkIDAMAzm5ubgcDgwOjoqFBdxYm9vD8vLyxgdHUVZWVnIz/3hD3+IT3ziE+js7MTKygra29tx66234pZbbsENN9yQsvdaqiO86kDQRThWoXWJJtRo197eHhYWFtDZ2RkwmsC1oQ03EkVCbg4ODjA6OgqpVBrT3yETyc/PR1NTE5qamuByuaDX67G3t4f19XXk5ORAIpHg+Pg4rU4B+YDb7aYOOxMTE2m/WUiWbmNrawubm5sYGRkR1os4QNZ8pVKJ4eFhXuhasrOzUVNTg5qaGpryTIIk5+fnaWFbWVmZMkU9wzCYnZ2F0+nE2NiY0E2OE/v7+1heXsbIyEjY4uKFF17A//f//X/4l3/5F3zgAx+AxWLB008/jSeeeALvfOc74XK58Na3vhUf/OAHz5URJhA9QoFxCqko8gaCFxgsy2J1dRVqtRojIyOorKwM+PdIxdwejwfz8/NUC5DOM7bJgmxyj4+P0dPTA4lEAq1WC4VCAZFI5CMSFzoaZ4eEFBYUFJxbBJuqxFu3Qdaeg4MDjI2NoaSkJA6/hQA5DGtqakJ7e3uSryYQbspzZ2cnrFYr9Ho9NBoNlpeXUVhYSO+108S7yYabJSIUF/GDHHYMDw+HPYz4wx/+gDvvvBNf/vKX8YEPfAAikQjFxcW44447cMcdd4BhGMzMzOCJJ56AwWBI0G8gQBBGpHB94fDvVtjtdjz//PO48cYbebnYncaLL76IixcvUvcbj8eDubk5Ov7hr82IRsxtt9uhUCggkUgSlmicabAsi42NDajVagwODvo4ezEMQ0XiOp0ObrebjhyEE4kL+HJycgK5XI7KysqAUUGB2Og2GIbB4uIijEYjRkdHheyEOGE0GtHY2Ajgeqco1cbPiK03CZIUi8V0TauoqOBF4U+KC4/Hg5GREWGtjRMajQYqlQpDQ0MBrpb+zMzM4G1vexu+8IUv4OMf/3hK7dMyBaGDgeAjUuQB6vV6U2p+j9vBICFWOTk5uHz5ss/4h7+YO1xxYTabMTs7S2d7hQ1Z7GEYBgsLCzCZTJiYmAgoBsViMcrLy1FeXo6uri6cnJxAq9Via2sLKpXKZ5Y+k22Cw0GMCZqbm9MyZT4W+LufkfGW9fV16hRE3M+C3WtE12K1WjExMSHcj3FCr9dDLpfT/+bDZjxauLbe5BBFp9NhZWUFTqfTZ5QqGfeR1+uFQqGA1+vF6OhoSu0HUgkSHut/sBaM2dlZXL16FZ/97GeF4oLHCB0MXN/Yud3ugI/95je/wetf//qU8raenp5GdXU1SkpKIJPJUF1dHSAO9hdzh3OKOjg4wOLiItrb2wOC+ARig9vt9jkhi/aes9lsVCR+dHSEkpISOkolnBy/AnEx6u7uRn19fbIvJyUhug2dToejoyNqSEDuNbIhYxhGOO2NI1qtFvPz82hra0NfXx+A62t1uoyhsSxL7zW9Xk/vNdJJKy4ujvvG0v9eFoqL+KDT6TA3N4eBgYGw4bFKpRI333wzPvGJT+Czn/2sUFzwGKHAQPACAwCeeuopvOpVr0qpDZpcLodYLIZWq0VHR4dPtgcQnd6CO64zMDAQoN0QiA1EC5Cfn4/BwcFzn0KSWXqtVguj0Yj8/Hy6AeTrfHMiUKvVWFtbE1yMYghXt0FS671eL/Lz8zE6OioUF3Hi4OAACwsLGBgYQGFhId2UabXalHpeRQMxvyD3Wk5ODi02pFJpzLs3Ho8HCoUCADA8PCwUF3FCr9djdnYW/f39qKmpCfm5i4uLuPnmm/Fnf/Zn+MIXvpCxz7JUQSgwcHqB8cwzz2BiYiJlToRYlsV//Md/wGazYWRkJGATFU1x4fV6oVKpcHx8jOHh4ZC5GgJn5+joCAqFAjU1NXGxlSRWkWSWnoy+VFdXQyqVZsSoG8uyWFtbw97eHkZGRoQE9DhhsVgwMzNDxzSTmbeRzhC7XzKnfnR0RG3CDQZDRoyjMQwDo9FICw63242Kigp6v53XDc7j8UAul0MkEmFkZCQlR89SARK62dvbS3Wjp7G6uoq3vvWtuPvuu3HfffdlxLMr1REKDFzfgLhcroCPX7t2DUNDQylhq0iSnvV6PWprazEwMODz79GIuZ1OJxQKBcRiMYaGhtLeujNZkJnTtrY2NDU1xf00hmEYmEwmKhL3er00STxdN4AMw0ClUuHo6AgjIyNpe7qbbCwWC2QyGaqqqtDd3Q0APnkbNpsN5eXlIXUbAuHZ3t7GxsaGj8MOV+R9dHSUlu/jUJDQUnKvnZyc0BHRs9gtezweyGQyZGVlYXh4WCgu4oTRaIRCoUBPTw/q6upCfu7m5ibe+ta34k/+5E/w9a9/XSguUgShwMDpBcYLL7yArq4u3o9TOBwOuiAWFRVBJBKht7cXQPTJ3MRdRwh2iy9kXKe/vz/szGk8YFkWx8fHdJQqkYFricLj8VBbybPoWgQi4+joCHK5HA0NDafmL4TTbQijDqFhWRabm5vY3t4OSDXW6XRoaWkBcL3Qy/TX0ul0Ut2GwWBAbm6uzyhVqGea2+2GXC5HdnY2hoaGhOIiTpDA366urrBaOLVajRtvvBG33norvvWtbwl7khRCKDBweoHx0ksvobW1NWzrLpkcHR1BJpOhsrISfX19WF9fh9PpRH9/v094HhC+uCAn6q2trWhpacn4B1U8YFkWy8vLODw85NW4DtkAarVaGuhHNoCpmHXidDohl8uRk5ODoaGhjDvVTRRkxCEaAwgyS6/VaukG8Lx5G+kMGfHb39/H6OgoiouLff794OAA7e3tEIvFODk5SdJV8hNit0yKW4ZhUFFRQcf2uN15t9sNmUxGbdiF4iI+mM1myGQydHZ2oqGhIeTn7u/v4y1veQve+MY34rvf/a6wNqQYwlMXwW1qAf6neR8eHmJ+fh7t7e20ICDXzNVbiESikG9MlmVp672vry+s0ErgbHi9XszPz8NqtfIupJAbuEZOALVaLdbW1mgIVnV1dUKcW86L1WqFXC5HWVmZ0IWLI8SRq6enh2oAIkEikeDChQu4cOGCzwZwfn5e0G34QQ4ktFotxsfHg474kQMkYUMciL/d8vHxMfR6Pba3t6FSqehBilQqxeLiInJzczE0NCSsGXGCdDs7OjrCFheHh4e4+eab8epXvxoPPPCA8DdJQYQOxsu4XC74vxQymQwVFRVobm5O0lUFh2VZrK+vY2trC4ODgz4jNtvb29Dr9RgaGopIb0HCsAwGA4aHh1NG0J5qEF1LVlYWhoaGUsZdx+Px0NNmvV6PnJwcWmzw8bSZPMDq6+vR3t7O+2IoVSFC41g6cnHzNri6jUzNdmFZlubijI2NIT8/P+jnbW9vo7e3F3l5eUJacRQ4HA7odDpoNBqYTCZkZWWhvr5e6KTFiePjY8zMzFDNYSi0Wi1uvvlmDA8P40c/+lHGHzSkKsJfLQR87GCQU3Cz2YxLly4FtMvFYjFsNhssFgvVY5yGy+XC3NwcPB4PJicnM+4BnigsFgvkcjmkUmnKnahnZ2ejtrYWtbW11LmF+O8zDEOLDT4k7pJTcCGvJX6wLIutrS1sbW1hZGQkpgYYIpEIZWVlKCsrQ0dHBx3bOzw8xPLyMtVtVFVVhV3bUh2GYaBUKmGxWDA+Ph5ybSb6OmETFh15eXmoqanB7u4uKisrUVdXB4PBgLm5uYBOWqocCPGVk5MTyGQytLa2hl2bDQYDbrvtNvT29uLf/u3fhPs6hRE6GC8TrIOhUqmQk5ODzs7OJF2VLw6Hw8c6jytaJWJuu92OhYUFGI1GFBQUoLq6OuhoCxkjKS4uRn9/f9I3h+kKSY1ubGw8VQCbinBPm7VaLRwOByoqKqhLUKKdx/b29rC0tBSRl7rA2WBZFqurqzg4OAiqBYgn3AwEvV6f1roN4gjodDoxOjoa9r20urqK4eFhlJaWYn9/P0FXmfq4XC7MzMygsLAQ/f399B7irm16vR5WqxVSqZSmifNptDUVsFgsmJ6eRnNzM1pbW0N+rslkwtve9jY0NjbioYceEhwsUxyhwHiZYAXG0tISWJZFT09Pkq7qFY6PjyGTyVBeXu6zGAIIKub2er0Boy3V1dWoqamBx+PB/Px82m16+cb+/j4WFxfTPjWam7ir1WpxcnKCsrIy2t04bbQjVj+bhEEODQ2hvLw8bj8rkyGjlEajEWNjY0ndZAUT7pJiI9V1GyQ52uv1RpyCvri4iPHxcVRUVECtVifgKlMfp9OJmZkZFBUVBTxP/bHb7fReM5lMKCgooPdbaWmp8PwMgdVqxfT0NHWYC8XR0RGuXr2KiooKPPbYY4LrXxogFBgv43a76QadsLq6CofDEZApkWg0Gg3m5ubQ1taG1tbWoMnc5M8YbKEkD2StVovDw0MwDAOpVIrW1taMCVtLJNxN7+DgICoqKpJ9SQmFzDZrtVqYTCYUFRXRYiOWoy0Mw2BpaQl6vR4jIyMJPVHPJMhYpt1ux8jICK9GKdNJt+F2u6FQKCASiaJKjlYqlbh06RKqqqqwtbUV34tMA0hxUVxcjL6+vqief263GwaDgXbTRCIR7WykenEba0hxUV9fH/Yg8+TkBG9/+9tRUFCAX/ziF3E9lBJIHEKB8TLBCozNzU0cHR1heHg4KddENqobGxsYHBwMGP2IJpmbYRisrKzg4OAAbW1tsNls0Gq18Hq9vJqjT3UYhqHCzJGRkYxPQHe73T6WpBKJxEckftZig2x6bTYbRkdHU2ojmUp4PB4oFAowDBPxiXoyOS1vg++6DZfLBZlMhtzc3KgtUhUKBW644QbU1tZifX09jleZ+jgcDszMzKC0tBR9fX3nuh8YhvEpbv2zhDJ5TbLZbJienkZtbS06OjpCvs5WqxXveMc7IBaL8ctf/lIIQ00jhALjZYIVGGq1mtoDJhqv1wuVSgWj0YjR0dEAdydu5yJcvoXb7cb8/DwcDgdGRkbo6QCx7dNqtdBoNHA6nTTZubKykvebCb7hdrsxOzsLj8cjBLsFgdtJ0+l0AECLjfLy8og3VS6Xy+ekV7hP4wPZ9EokkpQMHUsV3QY5US8sLMTAwEDU1yWTyfDqV78aDQ0NWF5ejtNVpj6kuCD21bEuNklxq9frYTabUVRURIXiJSUlvC1uY43dbsf09DSqq6vR2dkZ8ve22+2488474XK58Ktf/SquXej77rsPjz76KJaWlpCfn48rV67g/vvvR1dX16lf88Mf/hD33HOPz8dyc3PhcDjidp3phNDPe5lgb4Ls7Gzq0JFISEgYy7KYmpoKKuYmmotwnQu73Q65XI68vDxMTEz4bMZEIhFKS0tRWlqK9vZ2WK1WaDQabG1tQaVSoby8HNXV1WmT7BxPyOucn58f1XhDJuHvSW82m6HVarG8vEyLW/LvpxUNdrsdMpmMzk6n2qY3VSCvMzGB4MtmPBpC5W3wRbdht9t9Nr1neZ3JM0p4L5yOw+HA9PQ0ysvL0dPTE5fNPjdLiHRudTodZDIZxGIxvd+iOUxJNUgRV1VVFba4cDqdeM973gObzYannnoq7iOuzz//PD7ykY9gYmICHo8Hn/nMZ/CWt7wFCwsLIbsmJSUlPoV7phSKsUDYBYUgKysr4QXGyckJZmZmIJVKAzZQ/mLucMWF2WyGQqFAbW0tOjs7Qz68RCIRioqKUFRU5DNCtb+/j6WlJZSWllJHKmE+0pejoyMoFArU1NSgq6tLWIAiQCQSQSqVQiqVorOzExaLBVqtFmq1GgsLC9S1pbq6mo4aEKtD4XWOLxaLBTKZDFVVVeju7k6L19m/uCWjLevr65ifn0/KaIvNZsPMzAwqKyvP9ToTK3XhUCM4pIiLZ3HhT05ODurq6lBXVweGYWAymaDX6+lhCvd+S5fDO24RF259drlcuPvuu6HT6fDb3/4WpaWlcb++X//61z7//cMf/hDV1dWYmZnBa17zmlO/TiQSoba2Nt6Xl5YIK1IIsrOzE5qDodVqMTs7i4sXL+LixYtRi7m5EAejzs5ONDY2Rn0tBQUFaGlpQUtLi49od3V1FUVFRbTYyHSNgVarhVKppOFB6bAZSzQikQjFxcUoLi5GW1sbdW3RarVYWVlBUVERiouLodFo0NLSEmB0IBA7SFBhY2NjwBqULvjnbZDDlETmbVgsFszMzKCuri7sjHo4hA7G6ZBxnfMWcedBLBajoqICFRUV6OzspKNU5PAuVXRCoSBjflKpNGwR53a7cc8990CtVuOZZ56JaZZONBwdHQFAWOdBi8WC5uZmMAyD0dFRfOlLX0JfX18iLjHlETQYL+P1egOKCbPZDLlcjte//vVx/dkkvGptbQ0DAwMB1TLpXHi93rBdC5LyvbOzExcHI7fbTTd/BoMBeXl5tNjIpDlT4LpGZ21tDX19fUL2QpxwuVxYX1/H7u4uRCKRz/0mWETGFoPBgNnZ2YwOKkyEboNYjseqiLt27RpuueUW9PT0YHp6+tzXly6QDlFVVRVvO57c+81gMCAnJ4eOipaXl6fEaKLL5cL09DRKSkrCCuc9Hg8++MEPQqlU4rnnnkN1dXUCr/QVGIbBbbfdBrPZjBdeeOHUz3vppZewurqKwcFBHB0d4Wtf+xp+97vfQaVSoaGhIYFXnJoIBcbLBCswTk5O8Ic//AFvfvOb4/ZzGYaBSqWCXq/H6OhoQKswGqcor9cLpVKJk5MTjIyMxN2NwePxwGAw0KyN7OxsqtmQSqW8XNBjAcuyWF5exuHhIUZGRhLS3s1Utre3sb6+jsHBQUilUp/7jVhEkjn6VHgY8xWNRgOlUone3l7U1dUl+3J4QbC8DWKCcVbdBjm0am1tRUtLS0yu85lnnsFtt92G/v5+/Od//mdMvmeqQ1yMampqwmoB+ILX64XJZKL3m8fjQUVFBbXB5WPo3GlhhcHwer340Ic+hD/+8Y+4du1aUteZD33oQ/jVr36FF154IapCwe12o6enB+9+97vxxS9+MY5XmB4II1IhICJv4tQUa1wuF+RyObxeL6ampgJmf4neIpLiwuFwQKFQICsrC5OTkwlZjLKzs1FTU4OamhowDEMdgubm5gCAnjSnyklMJBB7VKvVisnJSSHVNU6wLEttlcfGxmgRR+4phmGoSHxpaQlut5ue/AkOaNGxu7uLlZUVDA4OoqqqKtmXwxv8dRvEce+sug3SIero6DjT2OppCCNSvlitVszMzERkkconsrKyUFlZSce5LBYLdDoddnZ2sLCwgJKSEnq/FRYWJv33crvdkMlkKCgoCFtcMAyDj3/84/jDH/6A5557LqnFxUc/+lE88cQT+N3vfhd1FyInJwcjIyNYW1uL09WlF0KB8TLB3qxkwWYYJuaLNxGslpaWYmBgIEDMTToXQHgx9/HxMRQKBSoqKtDT05OUzbxYLKaLY09PDz2JWVxchMfjOffJHx9wOp0+RZywiY0PDMNAqVTi+Pj41CJOLBajvLycCgpPTk6g0+l8HNAEP/rQkNHMra0tjIyMJG0WOhXgOu4R3YZOp4tYt0Hcq7q7u3HhwoWYXptQYLwCCXe7cOEC2tvbk74JPytcXdrFixfhcDjoKNXGxgYd3ausrExKWC4pLvLy8sJaKzMMg7/6q7/CtWvX8Nxzz8W0uI4GlmXxsY99DD/72c9w7do1tLa2Rv09yAHjzTffHIcrTD9Sc6eXIMhG2OPxxHTx1ul0mJ2dRXNzc8AiGK2YW6PRQKVS4eLFi2hububFgioSiejmr7Ozk578ra2tQalUoqKigo5Spcom3WKxQC6Xo6ysLOr0V4HIIVkiXq834k6cSCRCSUkJSkpKqAMad/NHTv6qq6uFEKeXYVkWq6urODg4wPj4uJCCHiUFBQVobm5Gc3Ozzxz91tYWDZMkug2dTgelUon+/v64aLVIgZGqBzexggjnI0mOTjXy8vLQ0NCAhoYGn9E9pVIJhmF8Rqni/Uz1eDyQy+WQSCQYHBwMW1x8+tOfxpNPPolr167FbCzwLHzkIx/Bgw8+iMcffxzFxcU4PDwEAJSWllJnzLvvvhv19fW47777AAB///d/j8uXL6O9vR1msxlf/epXsb29jT/90z9N2u+RSmT2ihQGEmAXK6talmWxvb2N1dVV9Pf3B7QJo8m3IKePm5ub6O/vT5pYKhz+J3/B7EjJ2Atf7fqMRiNmZ2fR2NiYdg8uPuFwOCCXy5Gbm3uuLBH/zR8xJdjY2EB+fj4tNjLNlIDAMAwWFxdhNBoxMTEhjPmdk1B5G0Q/19zcHHPDDYLQwbheXExPT6e1+xkh2Oget3tbWlrqM0oVS0hxkZ2dHVFx8bd/+7d45JFHcO3aNbS1tcX0WqLlO9/5DgDgda97nc/H//Vf/xXve9/7AFw3buH+TiaTCR/84AdxeHgIqVSKsbExvPjii+jt7U3UZac0gsj7ZViWhcvlCvj4b3/7W0xOTgYkaUcLwzBYWFiATqfDyMgIysrKAn5+pGJu8r2MRiNGRkZS9vTRbrdDq9VCq9Xi6OgIJSUltNjgy6aH2P12d3ejvr4+2ZeTtlitVshkMupVH48Okb8pAXlQV1dXJ2XMIBmQFr/dbsfIyIgwPhZH1Go1VldXUV1djZOTE9hstriM7j3yyCO4++678epXvzrA6z8TINlR5AAok7Hb7bSbZjQa6YFKVVUVSktLz7XGeb1eyOVyiEQiDA8PhyxoWZbF//yf/xPf//738dxzzwkb8gxF6GCEIRZp3i6XCwqFAh6P59xibpfLhdnZWTAMg0uXLvH21D8S8vPz6Umz0+mkJ81ra2soLCz0ydpI9IkUy7LY2NiAWq3G8PBw3E4fBV4JhGxoaIhrh8jflIDohFQqFbxeb1rohEJBxs8YhsH4+HjKjCemIqS7PDY2Rg+TotVtRApXq5dpEMvf5ubmM83Upxv5+flobGxEY2MjPVDR6/WYnZ0FAKqTrKioiOr97/V6oVAowLIsRkZGwhYXX/3qV/G9730Pzz77rFBcZDDp9xSNMVlZWecK2yOpuMXFxRgdHfXZuEQr5rZYLFAoFNRvOp1a4rm5uXTG1O12Q6/XQ6vVYmtrC7m5uaipqUnYWAvpEJlMJkxMTGR8mGA8IUGFsXbWCQc3/Kqrq4uOGRCHIDLTnC5Juy6XCzKZDBKJJOwGQeDskByi3d1djI2N+XS+Q+k2cnJyaDct2rwN8nzKtL/p8fExZmZmaPimgC/cAxVuev3GxgaUSiWkUild44gGIRher5fq4kZHR8MWF//0T/+Ef/qnf8LTTz+NwcHBePxqAimCUGCE4TwdDCLmbmpqCrDL8xdzE73Haej1eszPz6OpqSntZ0xzcnJQV1eHuro6eL1eOtYik8mQlZVFOxuxCr7iQk55PR4PJicn02JzyVeIPWqyNURcnVB7e3tA0i6ZaebT6F402O12yGQyejCRiSfdiYBYKx8eHmJ8fDzkwUQo3Ua0eRuZKPI+OjqCTCaLaZ5IOhMsvZ4UuCsrKygoKPAZpSL7C4ZhMDc3B4/HE3BA6g/LsvjOd76Dr3zlK3jqqacwNjaWqF9PgKdkzooUhtM27FlZWVEXGCzLQq1WY2VlBX19fQG2hNHoLYBXEqN7enoyLgSLW1CQsRaNRoP5+XmwLEs3fuXl5ec+wbPb7ZDL5cjPzz+XyFggNNy0eT7aoxYWFqKwsBAtLS1BR/fIPVdcXMz7Qp90UKurq3mbZpwOsCyLxcVFGAyGqIXzp4l2I83bYBiGfp9MgBQXxDlRIHoKCgrQ1NSEpqYmuN1uGAwG6HQ6qrEg4aUHBwdwOp0YGxsLW1x8//vfxxe/+EU8+eSTmJycTOBvI8BXhB0UB5FIBH/Ne7QjUsShRaPRYHx8PGDzFK2Ye3l5GVqtFqOjowHC8EyDO9ZCWr4ajcYnaK26uhqVlZVRFwdHR0dQKBQ0+VU45Y0P/g5GfB8/447ueTweOro3PT19rrGWRHB0dAS5XJ4RzjrJhIxUHh0dYWJi4lzibf9uGtFtaDQaLC8vo6ioiFp8E90GeT5lwoEISUJva2tDU1NTsi8nLcjJyUFtbS1qa2tpgKlOp8PCwgK8Xi/Ky8txeHh4aoHLsix+9KMf4XOf+xx+/vOf44YbbkjCbyHAR9J/RTon0YxIud1uKBQKuFwuTE1NBcw1RiPmdrvdmJubg8vlwuTkZMgZyUyE2/Lt7OyExWKBRqOh86XcrI1wWQpEB0AeWsJGLD54vV7Mzc3B4XCceyOWDLKzs30exCS5noy1kGKjoqIi6afJJDW6vb1d2IjFEYZhMD8/D5vNhvHx8ZiPVEai2zg+PgaQ/h0Mk8kEuVyecL1WJiEWiyGVSrG3t4f8/Hz09PTAbDZTYwIAePLJJ/H2t78dN9xwA0QiEX784x/jr//6r/H4448HWMAKZDZCgRGGSDsYVqsVMzMzKCoqwqVLl84l5rbZbFAoFMjPz8fExERGnEydB27qKZmh12q12N3dxeLiIsrKyuiYlf+mloyf9fX1xSUES+A6LpcLcrkcWVlZaeFgxE2u5wooV1dXA0TikYQFxhKNRgOlUone3t6MG6lMJET86na7MTY2Fve/82m6jZ2dHQDX7VoPDw/P1MHlO6S46OzsRENDQ7IvJ21hWRYqlQonJycYHx+HRCJBWVkZWlpa4HK5MDc3h7W1Ndxxxx3Iz89HW1sbZmdn8ZOf/ARvfOMbk335AjxDyMHg4Ha76TwrYXFxEQDQ09Nz6tcZDAZqs9nZ2XkuMbfJZMLs7Czq6uoCvpdA9DgcDpq1YTabUVxcTDsbe3t7ODg4wPDwcMaPn8UTm80GuVyO4uJi9Pf3826UKJawLEtF4lqtFicnJygrK6PdjXh3IolwfmBgAFVVVXH9WZmMx+Ohtp3Dw8NJLZi/9a1v4VOf+hRuvvlm/OVf/mXc8jaShdFohEKhQFdXl5BFFEdYlsXCwgLMZnPYbpzD4cAXv/hFfOtb30JlZSWOj4/x5je/GW9729tw6623ora2NoFXLsBX0uuYIw5kZ2fD6XSe+u9qtRrLy8vo7e0NWPy4eguRSBR2Y7W3t4elpSV0dXUJpzQxIi8vj4rZSKqzRqPB2toaRCIR6uvrkZWVBZZlhWIuDhwfH0Mul6O2tjYjCmaRSISioiIUFRWhtbUVDoeDFhurq6soKiqixUYs811YlsXW1ha2trZ4KZxPJ9xuN+3G8cHyl3TGS0tLceXKlYh0G6kCGfXr7u4OMEsRiB3EpMBkMkU06vfMM8/ge9/7Hn7605/ijjvuwMLCAn7+85/jBz/4Af78z/8cY2NjeNvb3oZ3v/vdGR9+mMkIBUYYsrOzYbVaAz7OMAyWlpZwcHBwbjE3y7JYW1vD7u4uRkZGUF5eHvPfQ+D6iEFlZSV2d3dRWlqKCxcuwGg04o9//CMkEgkdo+La9AmcHbI5IG4vmfia5uXl0eArbr7L9vY2cnJyfCyXz/r6+NujFhcXx/i3ECC4XC7MzMwgPz8fAwMDSS8uAASIvOOVt5FohOIiMbAsi+XlZRgMBoyPj4fteP3mN7/BPffcg+9///t4xzveAQDo6+tDX18fPv3pT0Or1eKXv/wlfvGLX6C9vV0oMDIYocAIQzCbWiLmdjqdmJqaCrAkjKa48Hg8UCqVsFqtmJycRGFhYVx+D4Hrlp1yuRxlZWU0D6ChoYHOM2u1WigUCohEIrrxk0qlvH4I85WDgwMsLCwIOgAO/vku5J4jKbtkpCUakThxMDKbzVHbowpEh8PhgEwmQ1FREa9G/ULZ1EaSt1FVVcU73YZer8fc3FxGWrMnEnI4odPpMD4+HnaE87nnnsN//a//Ff/yL/+Cu+66K+jnVFdX45577sE999wTj0sWSCH4s6LwgGCFgL/I22q1QiaToaCgAJcvXz6XmNvhcEChUCA7OxuTk5MpL3zlM0ajEbOzs2hsbERbW5vP34XrQ0+yNrRaLVQqFbxeL6/cgfgOy7LY3t7GxsYGhoeHUVFRkexL4iX+2QdmsxlarRYrKytwOp1041dVVXXquuD1ejE/Pw+73Y6JiQkhFDKO2O12zMzMQCqVore3l1fduEiTvE/L29jc3IRSqeSNbkOn02Fubg59fX3CLH8cIZMTxFI/XHHx+9//Hu9617vwzW9+E//tv/03Xr0HBPiJUGCEgWtTazQaIZfLUV9fHxBaxbIstaAFwou5Se5CVVUVuru7eXMalo7s7+9jcXER3d3dYUWC3KyN7u5uHB0dBWz8SNaGUBD6Qlrt5IFVUlKS7EtKCUQiEaRSKaRSKbVc1mq1UKvVWFhYgFQqpUUu2fiRxHmGYdLClYvPEIdAvoYVniXJO5K8jXhohcJBiov+/n7B1S/OrK+vY39/H+Pj42E7n3/4wx/wzne+E/fffz/e//738+49IMBPhAIjDGREamdnB0tLS+jp6QkQYPs7RYUrFg4PD7GwsCDkLsQZlmWxsbEBtVp9ptN0btZGR0cH3fhtbW1BpVKhvLycjlIl2oqUb3i9XiiVSlgsFiG35RxwLZfb2tpgt9upSHxlZQVFRUWoqKiAVqtFXl4exsbGhK5aHDk5OYFMJsOFCxfQ3t7Oy7Wa2zE/K6fpNohWiHQ24jkySjJlhOIi/mxsbGBvbw9jY2Nhx7Knp6dxxx134O///u/xoQ99iJfvAQF+IhQYHIK9ccRiMRwOB1ZWVjA2NhYgwI5WzL25uYmtrS3BRjLOkNl0k8kUk8Ro/42fzWaDVqvF/v4+lpaWUFpaipqaGlRVVWXc5pp7mj4xMZHxxVYsyc/P93FB29/fx8bGBj3QWF9fF4wJ4sTR0RFkMhlaWlrQ2tqa7Ms5lVgnefvrNsjIqFKpjJtug2S3DAwMoLq6OibfUyA4m5ubUKvVGB8fD/tcVCgUuHr1Kj772c/i4x//uLDGCESFUGCEwOPxYHV1FV6vFzfccMO5xNxer9dHjCk4vcQPsuH1eDxxS4wuKChAS0sLWlpafKxIySkzKTbOW9jwHYfDAblcjry8PF5YdqYzLpcLarWanqb7GxOQU+by8nLh73BOTCYTFAoF7TLzGdLBiMffPCsryydQMh66jcPDQ6hUKgwODgqHbnFma2sL29vbGBsbC/tsUiqVuO222/DJT34Sn/zkJ4XiQiBqhALjFGw2G2QyGZ1t5p5KEzE30VyEKy6cTid1ipmcnBTEmHHEbrdDLpcjPz8fw8PDCXFG4VqRkvECrVaLjY0N5Ofn0zGq4uLitFqkLRYLZDIZKioq0NPTI+iI4ojZbIZCoUBjYyMuXrzo43TGMAwViS8tLcHtdvucMgv6jOggDkapEuwWqcj7vMRDt3FwcIDFxUWhuEgAarUam5ubGBsbC3vAubi4iFtvvRUf/vCH8ZnPfCatnlsCiUMoMDiQN5HJZKJzt62trbh27RoYhqGBbFwxd7ji4uTkBAqFAmVlZejt7RVOFuMIEc4TMWYyNrzc8QKPxwODwQCtVovp6emY5R7wAXLC29TURDe8AvGB5AG0t7cHPU0Xi8UoLy9HeXk5urq6cHJyQnMPiFaID+5AqQDRAaSSvTJ5FiXaZva8ug1ucVFZWZnQa880dnZ2sL6+jtHR0bDmGysrK7j11lvx/ve/H3/3d38nrO0CZ0YoMPzY3d3F4uIiurq60NTURNvPXq8XYrE4KjG3TqeDUqlEc3MzWltbhTdqHCEzwnwSzmdnZ6OmpgY1NTVgGIYWG6SbRYqN8vLylDr912g0UKlU6OzsFBLn4wwZH4l0wysSiVBSUoKSkhKqFdLpdDg8PMTy8jJKSkroKbOQueMLyW5JNR1APEekIiVa3QbRrg0NDQlW1nFmd3cXq6urGB0dRWlpacjP3djYwK233op3vetd+NKXvpRSzyUB/iEUGBx0Oh2Wl5cxOjpKFz3SoXC73RCLxRGLudVqNdbX19Hb2yt4eccZtVqNtbU19PX18dZ9RCwW+2RtkJGWhYUFeL1eH/tbPne5dnZ2sLq6iv7+/pTahKUi5LU+z/iI/ykz0QqR8T1SbJSUlPCiKE8Wu7u7WFlZScnslliLvM9LON1GQUEBbDYb+vv7U+61TjX29/exsrKCkZERlJWVhfzc7e1t3HLLLbh69Sq+/vWvC8WFwLnhx4rEE6qqqnDDDTf4jBGIRCJkZWXB7XZDIpGELS4YhsHS0hJ0Oh3GxsbCnhgInB2SQnpwcIDR0dGwCyhf8B9pOT4+hlarxdraGpRKJSoqKlBdXR0yZC3RkFCmvb29lHqtUxHiNre9vR3T11oikaC+vh719fU+43symYyGsGViej0JhhwZGYFUKk325URNLGxq44W/bmNjYwMbGxsoLCyEUqnE1tZWUvI2MoGDgwMsLS1heHg47H29t7eHW265BTfeeCO+9a1v8fJeEkg9hAKDg0gkCphRZhgGeXl5mJ+fp+Mup7kvuN1uzM3NweVy4dKlS8K8cxwhKcZWqxWTk5Nhg4L4iv8D2Gq1BoSskVGqZJkD+Fv+CqM18YMUzYeHhxgfH4+b25z/+J7JZIJOp6Pp9fGwIuUbpJBTq9URjY/wlUSJvM/Lzs4Otra2MDY2BqlUCrfbTQ0xEpm3kQkcHh5icXERQ0NDAdb6wT73lltuwWte8xp85zvfEV53gZiRnk+OGMAVc4+OjtLTvq2tLeoMRIoNkUgEq9UKhUKBwsJCTExMpO1DmQ84nU4oFAqIxWJMTk7y5pT/vIhEIhQVFaGoqAgXL16E3W6HVqv1mZ8nxUaiCiqPx4O5uTk4nc64Wf4KXIcUcsTKOlF/Y256Pemo6XQ6bGxs0I4a2filiwMe6cjt7+9H5KrDZ86S5J1odnZ2sLa25tORy8nJQV1dHerq6sAwDIxGY9Ait6KiIm3W+ESg1WqhUqki0rdotVrccsstmJiYwP/6X/+L90WqQGohYoliWQDA9c1rqGRuj8dDT110Oh1yc3NRWloKnU6HhoYGdHR0CG3eOGKxWCCXy1FWVoa+vr6MOW1xOp10ft5oNKKoqIgWG4WFhXG555xOJ+RyOXJycjA0NMTrDUyq4/V6MTc3B4fDgdHRUd5s5K1WK73vjo+PUVpaSkdaUrVryLIslpeXodVqI0oy5jvvfe978fDDD+MrX/kKPvKRjyT7cgIgesRIdAAAfHQbOp0OVquVdnIFJ7TQ6HQ6zM3NRaTbMhgMuOWWW9DV1YUHH3xQKOIEYo6wY/AjXL5FdnY2amtrUVtbC6/Xi+XlZezt7UEsFkOj0YBlWdTU1AjJunHAaDRidnYWjY2NaGtry6jXNzc3Fw0NDWhoaPAZLdjc3EReXh4tNmIl1iU5MKWlpRlVyCUDt9sNhUIBABgfH+fVg76wsBCFhYVoaWnxKXLX1tZQWFhIi41UyXhhWdZn3I+bb5Sq8LmDQfQt0YygxSNvIxMg+S39/f1hiwuTyYSrV6+itbUV/+f//B9erTkC6QP/VqQkolQqoVAo8MY3vjHsRo1lWayvr9NTsLKyMjpGJZfLkZWVRTd9UqlUWATPyf7+PhYXF9Hd3Z0S4VfxhDta4PV6A8S63KyNsxQGR0dHkMvluHDhgtCRizOkS5Sbm4vBwUFejyhwi1xuJ5dkvJBN31nvu3jDMAyUSiUsFgvGx8fT5iScDza1wdja2sLm5ua59S1cJzRBtxEcg8GAubm5iJwUj46OcPvtt6O2thb/9//+X0gkkgRdpUCmIYxIcXjiiSfwl3/5l9jb28Ob3/xmXL16FTfddFPA4mgymfCJT3wC73nPe/CqV70qYFSAiCY1Gg20Wi1EIhGqqqpQU1OT0YvgWWBZFhsbG1Cr1RgcHBRsDUNA5pjJ+B7LsnTTV15eHtEGhJyCtbW1obm5OQFXnbnY7XbMzMykfJfI/75jGIZu+vhiu0xG0JxOJ0ZHR9NqU3XnnXfiySefxLe//W3cc889yb4cAPBxQQsX7HZWuLoNnU6XsboNo9EIhUKBnp6esFk5JycnePvb347CwkL8/Oc/j3sH77777sOjjz6KpaUl5Ofn48qVK7j//vvR1dUV8useeugh/M3f/A22trbQ0dGB+++/HzfffHNcr1Ug9ggFhh8Mw2Bubg4PP/wwfvazn2F9fR1veMMbcPXqVdxyyy3Q6XR4xzvegYqKCjz88MNhW5Esy9LQITJCRTZ9FRUVKbupSARc96Lh4eGUFmImGpZladaGVquF2+32ydoINk5BukR9fX1CdkucsVgskMlkNHU+XbpELMvi6OiIjlI5HA4fkXgyNvZerxcKhQJerxcjIyNpt/G844478NRTT+E73/kO7r777mRfDj0QSqR4PlN1GyaTCXK5HN3d3bhw4ULIz7VarXjHO94BsViMX/7ylwnRHr31rW/Fu971LkxMTMDj8eAzn/kMlEolFhYWTv35L774Il7zmtfgvvvuw6233ooHH3wQ999/P2QyGfr7++N+zQKxQygwQsCyLBYXF/Hwww/j0UcfhVKphEgkwuDgIH7yk5/gwoULUW0MyMOXdDY8Hg8qKytRU1ODiooKXpz08QVi+et2uzE8PJy2D4hEwLIsTk5OaLFht9tRXl7uk7WxtbWFra2tiGwNBc6H2WyGXC5HU1MTLl68mDbFhT8sy/qIxE9OTlBWVkYPWBKhfyD6FpFIhOHhYV7qFM7L1atX8dvf/hbf+9738J73vCep17K+vo6dnZ2kO3PZbDY6SmU2m9NSt2E2myGTydDZ2YmGhoaQn2u323HnnXfC5XLhV7/6VdL+NjqdDtXV1Xj++efxmte8Jujn3HXXXbBarXjiiSfoxy5fvozh4WE88MADibpUgRiQfqttDBGJROjt7cXnP/95tLe340//9E/xhje8AYeHh+jt7cUNN9yAq1ev4rbbbkNtbW3YRUskEqGsrAxlZWXo7OykAWsrKytwOp10AUxn7/lIsNvtkMvlyM/Px/j4eEa/FrFAJBKhpKQEJSUlPlkbu7u7WFxchEQigcfjEYqLBEBG0Do6OtDY2Jjsy4krXNvl1tZWOBwOWmysrq6isLCQ6oXiselzuVyQyWQpoW85D3xI8iaaxL29PYyPj5+aFZUoCgoK0NTUhKamJqrb0Ol0+OMf/5gWug2ik+vo6AhbXDgcDvyX//JfYLPZ8NRTTyW18Ds6OgKAkM+Zl156Cffee6/Px2688UY89thj8bw0gTgg7NzCwDAMvvCFL+Ab3/gGHnnkEdx0001gWRZbW1t45JFH8NBDD+Gv//qvcfnyZdx22224evUqGhoaIio2uE4ZFosFGo0GGxsbUKlUqKioQE1NDSorK9OupR+Ko6MjKBQKOjqSios/3yksLERrayuampowOzuLk5MTFBYWQi6X06yNqqqqlLfv5BuHh4dQqVTo7e0NOyudjuTl5aGxsRGNjY1BxbrkvouFSNzpdEImk6GgoAADAwNpvY4wDAMgeSJv/0yRZBcX/oTL26ioqKAjy6nwrD0+PoZMJkNbW1vYQwqXy4W7774ber0ev/3tb5MaJskwDD7xiU/ghhtuCDnqdHh4GCBUr6mpweHhYbwvUSDGCAVGCOx2O973vvfh//2//4f/+I//oG8KkUiE1tZWfPKTn8Rf/dVfYXd3F48++igeffRRfOYzn8HY2BiuXr2Kq1evoqWlJaJio7i4GMXFxbTYIA9elUqF8vJy1NTUJG2GOVFotVoolUpcvHgRzc3NadHG5itkdIRlWUxNTUEikcDlcgXYkMbzhDmT2NnZwerqKoaGhlBZWZnsy0k6/k5oRCQ+NzcHAPSE+Syjo0Q8X1ZWht7e3rQuLoDkJnlzi4vx8XHeH0qIxWJUVlaisrIS3d3dVLexubkJpVIJqVRK7z0+WhifnJxAJpPRA6JQuN1uvO9978POzg6effZZSKXSBF1lcD7ykY9AqVTihRdeSOp1CCQOocAIwcc+9jHs7u7iP//zP1FdXR30c0QiERobG/EXf/EX+PjHP47Dw0P87Gc/w6OPPoq//du/xcDAAC02IrX85KY522w2n3EWIlyrrq7mTRhXLFCr1VhbW4vIZk/gfJARNHK6SzYmEokE9fX1qK+vDzhhlkgk9L4TMl4ih2VZH0edSILGMo2srCy6qeOaE5DRUeIMRPRCobDZbJiZmaEbyEy4T5OVg8GyLFZWVqDRaFKiuPDHf4rAbrfTA5aVlRWq26iqquJFzovFYsHMzAyam5vR0tIS8nM9Hg8++MEPYnV1Fc8991zS3Rc/+tGP4oknnsDvfve7sCNdtbW10Gg0Ph/TaDSC8UgKIoi8Q6DRaFBaWnomgTHLsjAYDHj88cfx8MMP49lnn0VnZyeuXr2K22+/HT09PVEvWHa7nQp1j46OUFpaipqaGlRXV6esCJo8pA4ODjA8PCxswOLMyckJ5HI53YBFcrrLzdrQ6XQQi8U+GS/pfkJ8Vsi9fXh4iNHRUcEFLUpYloXFYqGbPovFQk+Yg615ZANWV1eXUfktr33tazE9PY2HHnooYVae/sVFqqa6nwZXt6HX65Ou2yD3dkNDA9ra2kJ+rtfrxYc+9CFMT0/j2rVrSd2YsyyLj33sY/jZz36Ga9euoaOjI+zX3HXXXbDZbPjFL35BP3blyhUMDg4KIu8UQygwEgA5lfv5z3+ORx55BE8//TSam5tpsXGWGWEimNRoNDCbzXR2vqamhpet3WB4vV7Mz8/DarViZGQk7R5SfIMkoTc3N6O1tfVMGzCS8UIKXZJ5QGaY01VIGy3EYtlsNmN0dFS4t2MA94SZOAORQtfr9UIul6OxsTGtnbmCccMNN0ChUODRRx/FjTfeGPefx7IslpeXodPpMDY2lvb3drC8jUTqNqxWK6anp1FfX4+2traQ9zbDMPjYxz6G3//+97h27VrYbkG8+fCHP4wHH3wQjz/+uE/2RWlpKd2n3H333aivr8d9990H4LpN7Wtf+1p8+ctfxi233IKf/OQn+NKXviTY1KYgQoGRBI6Pj/HEE0/gkUcewa9//WvU1tbitttuw9vf/naMjo5GXWy4XC664TMajSgqKqKdDb62rZ1OJxQKBcRiMYaHh1NCXJfKEIFxLJPQie0yuffIOAtxQsvUvykJdXM4HBgdHU2rUUa+4HK56AifwWAAwzAoKytDR0dHxo3wXb58GfPz83j88cfxpje9Ka4/i2VZLC0tQa/XY3x8PGUOs2LFaXkb8dJt2Gw2TE9Po66uDu3t7WGLi7/6q7/Cb37zGzz33HNhx6gSwWnX+6//+q943/veBwB43eteh5aWFvzwhz+k//7QQw/hc5/7HA3a+8pXviIE7aUgQoGRZCwWC371q1/hkUcewZNPPgmpVIrbbrsNt99+OyYnJ6M+EXa73bSzYTAYqFC3pqYGhYWFvHjwWiwWyOVylJWVpXSCcapA9C0DAwNhgyHPChlnIcWG1WqlWRvV1dVpbU7AhYjnAQiFcwIwGo2Qy+XUIUiv10MkEtENX6QJ9qnM+Pg4FhcX8cQTT+D1r3993H4OyYUyGo0YGxvLuOIiGKSrptPpYDKZYqrbsNvtmJ6eRnV1NTo7O8MWF5/+9Kfx+OOP47nnngs7RiUgkAiEAoNH2O12PPXUU3j00Ufxi1/8AgUFBXjb296G22+/HVeuXIlaxOfxeOhIgV6vR15eHu1sJEu0RsZ0Ghsbw7Z7Bc4Hy7JYXV3F/v4+RkZGEmpRyA1YOz4+RllZGbUhTdeNCbFGzcvLS+vcBb6g0+kwPz/vk2LMMAzMZjO990iCfVVVVdp21UZHR7G8vIxf//rXePWrXx2Xn8GyLBYWFmAymTA+Pp6ymr94EkvdhsPhwPT0NCorK9HV1RW2uPj85z+Pn/zkJ7h27Ro6Oztj8esICJwbocDgKQ6HA8888wweffRRPP7448jKysKtt96Kt7/97Xj1q18d9YPS6/VCr9dDo9FAr9dTV6CamhqUlJQkZKO/v7+PxcXFmI7pCASHYRioVCocHR1hZGQkqaNy3IA1k8mE4uJi2tng6whftGSaNWqy0Wg0UCqV6O/vP9V1jiTYk3uPdNXIpi9dNslDQ0NYW1vD008/jStXrsT8+7MsS9eSsbGxtHnd4slpuo1ICl1SXJSXl4c1g2FZFv/jf/wP/OAHP8Bzzz2H3t7eePw6AgJnQigwUgC3243nn38eDz/8MB577DG43W7ceuutuHr1Kl7/+tdHPePt7wqUlZVFOxtlZWUxLzZYlsXGxgbUajUGBweTbpmX7ng8HszOzsLtdmNkZIRXGgAyO6/RaGA0GpGfn0+LDT5YQZ4F4vBSU1MT9rRR4Pzs7+9jaWkp6pE/m81Gi42joyOUlJRQg4JULnT7+vqwtbWF5557DpOTkzH93qS4OD4+xtjYGK/WklSBFLrkeRtKt+F0OjE9PU0PKsIVF1/5ylfwL//yL3j22WcxMDCQiF9HQCBihAIjxfB4PHjhhRdosWGxWHDzzTfj6tWreNOb3hT1+Ak5aSGz8yKRKKYWpAzD0Lnd4eFhwaozzjidTsjlcuTk5GBoaCjh3vjR4PF4qFCXjBSQey8ehW48MJvNkMvl53LmEogcElg4PDyM8vLyM38fbqik0WhEXl4evfcS1dGNFd3d3djZ2cHvfvc7jI2Nxez7ki7oycmJUFzEkNN0G2VlZVhaWkJpaSn6+vrCFhff/OY38bWvfQ2//e1vMTo6msDfQEAgMoQCI4Xxer34wx/+QIsNvV6PG2+8EbfffjtuvPHGqE/lyPyyRqOBVqsFy7KoqqpCTU0NysvLoy423G435ubm4Ha7MTw8LLTW44zVaoVMJoNUKk25MR1umrNOp6NC3erq6jPde4lAr9djbm4OHR0daGxsTPblpD1bW1vY3NzEyMhITPNyPB4PDIb/v737Dmvy3P8H/g4IAjIDJCCyFBQHG1TUOloVFSShtbWetmrHsUtPrR2ntp5qx6nH2mFbrR2eU3q6tJCA1llF0Vo9KlOGoCBLhYQZZsh4nt8f/vJ8xUXAEEY+r+vqdbXhSbhDM573c9/351PHnfQNtD4vfn5+qKqqwsmTJxEaGmqQx2QYBnl5eWhtbUV4eLjJFGkwNt2+DZlMxr32hg8fftfXHsuy+PLLL/HBBx/g0KFDBp+1IsRQKGAMEgzDID09HUlJSUhOTsa1a9cwe/ZsiMVizJ8/H/b29t16vBs76spkMmi12m71O9B1i7a2tkZgYGC/vpI+GCgUCmRlZcHDw6PLcob9nS7o6mbVtFptp/K3/WHztK7s77hx4+Du7t7XwxnUdEssKysrERYW1u3Psu7Q9XnRzW7oXnu6tfP98XPM19cXcrkc//vf/wyyTIZhGOTm5qKtrY3ChRGo1WpkZGTAysoKHh4e3EZxrVaL5uZmVFdXIz4+nut0v2PHDrz99ts4cOBAr+y5IcRQKGAMQgzDICcnBxKJBFKpFJcvX8YDDzwAkUiEmJiYbi8/0dX+1s1sqFQquLi4QCgU3vaET6FQIDs7GwKBAGPGjOn3VwAHOl01HT8/P3h5efX1cAxK99rThQ2lUsmd8Lm6uvZJVSDdMp2goCC4uLgY/febkhu7oYeHh8PW1taov1vX80Aul6OtrY3bqOvq6tpvlgx5e3ujtrYW586du+dNvgzDdOrhQuGid90YLoKCgrjvSt2+jT179mDTpk0oLy9HSEgI3N3dcezYMezbtw8zZszo49ETcncUMAY5XXnBpKQkSKVSXLhwATNnzoRYLEZsbCycnZ27HTZ0G9ZkMhl3wqcrQdrQ0IDc3FyMHDkS3t7eA/pK+kBw5coVFBUV3bWazmDBsixaW1u5sNHS0sL12jDGCR/LsigtLUV5ebnBl+mQW+n6LtTV1fWLjtE3l152cHDgZnX7cmweHh7cXqB7KVGquzDV0dGB8PDwQVnStz/RaDTIzMzk9svd7UJcYWEhNmzYgH379oHH42HChAkQiUQQiUQIDQ2l71nSL1HAMCG6vgi6sJGTk4Np06ZBJBIhLi4OQqGw22GjtbWVm9lobW0Fy7IYMWIE/Pz86AuqF91YmSs4OPieNrwOVO3t7VzYUCgUcHBw4NbOG7rXBsuyKCoqgkwmQ1hYGBUr6GUMw6CgoKDflkbt6OjotEncxsamz6qhubm5obm5GefPn+9xgzVd93mVSoWwsDD67O5lGo0GWVlZMDc3R3BwcJfLPhMTE/Hiiy8iKSkJkyZNwoEDB7B7924cOHAADg4OiIuLg0gkwsyZM2nWifQbFDBMlO5qrEQiQXJyMs6ePYuoqCjug8rDw0PvL0ndMoZr165BKBSiqamp09VlU+rkbAwMw6CwsBC1tbUICwsz6rKR/urmEz5bW9tOvTbu5YRPd7Lb2NhIHYyN4MY9AGFhYf1mKdKd3FwNbciQIdysmjE2ibu4uKC9vR35+fnw8fHp9v21Wi1ycnKg0WgQGhpK4aKXabVaZGVlgcfjISQkpMtwkZKSghUrVuCXX37BwoULO/2so6MDaWlp2LNnD3bv3o0tW7Zg0aJFvTl8QvRGAYOAZVlUVlZCKpUiOTkZf/75J8LDwyEWiyESie661Km1tRUXL15EW1sbQkNDuaUC7e3t3MyGrpOzUCgcVA2u+oJWq+108kV/y1up1WoubNTV1d1TCVLdlV3dmvT+frI70OlOdnU9XAbahYkby37X1NSAYRhuz0ZvFShwcnKCSqVCUVERRowY0a37arVaZGdnQ6vVUrgwAt3fm2VZhIaGdvl62Lt3L5588kn88MMPePDBB+96LMuyYBimXxTBIASggEFuwrIsqqqqkJycDKlUihMnTiAwMJALGzdWKKqsrOT2crz11lt3PBlQKpXcUpbGxkbY29tzjf3oarD+VCoVsrOzuStfdDLQNV0He93VZXNz8069Nu52dVmtViM7OxsA6O9tBBqNhjv5Ggx/b5ZloVAouLCrVCo77RkyVHiyt7eHVqtFcXFxtyqa6U52GYZBaGhov6yQNZjowrMuzHX19z506BCeeOIJ/Pvf/8bixYuNNEpCDIcCBrkjlmVRW1uLlJQUSCQSHD16FAEBARCJRBgzZgxee+01BAUF4aefftJ7k6NuKYtMJkNDQwPs7OwgEAggFAr7fBNnf9be3o7MzEzY2tpiwoQJdJWqB26+uqzr86IrvXxj2Ojo6EBmZiZX3YX+3r1LrVZza9L1WTYy0Oj2q+nCRnNzs0H2DLEsyy2RLC0thUAg0Ot+umU6uivpFC56l24DvVqtRlhYWJd/72PHjmHx4sXYvn07Hn/8cdrETQYkChhELyzLoqGhAXv27ME333yD06dPw9HREStWrEB8fDwmTJjQ7bXGN3bTraurw7Bhw7iZDdpX8H+am5uRmZkJoVCIMWPG0JeNAdzY50Uul0OtVnOll4cNG4bs7Gw4OjoOuIaFA5FKpUJGRgbXM2ewhYvbUSqV3GdfQ0MDhg0bxoUNW1tbvd/jWq2W6wtSUVEBZ2fnLu+j22DM4/H0WqZD7o2u9G9HR4deG+j/+OMPLFq0CFu2bMFTTz1Fn/dkwKLLFkQvPB4PfD4fQ4YMQU5ODj7//HPw+XxIpVI88MADcHd3R1xcHOLj4xEaGqrXSZmlpSU8PDzg4eHRqaNpaWkprK2tuZmN7nzhDjZ1dXU4f/48fHx84OPjY7J/B0Pj8XhwcnKCk5MTRo8ezZVevnTpEtrb22FtbQ0nJydoNJoBtw9gIFEqlZ1m5kwlzFlZWcHT0xOenp7cZ59cLkd5eTksLCy4ZVRdLePTaDTcv+sTFHThwszMbFDOFPU3uoIFSqVSr9K/p0+fxsMPP4wPP/yQwgUZ8ExmBmPbtm3YvHkzqqurERwcjC+++AITJ0684/GJiYn4xz/+gbKyMvj7+2PTpk1YsGCBEUfcv7Asi/fffx8fffQREhMTMXfuXO5nLS0t2L9/P6RSKfbv3w8+n4+FCxciPj4ekZGR3f4Su7kqi6WlJTez0d1NugNZVVUVCgoKMHbsWAwfPryvhzPo6XoJuLu7w9LSEjU1NWhuboaTkxN3wkeb6g2nvb0dGRkZcHJywrhx40zmfX03Wq220zI+ANwmcWdn51s+S9va2uDq6goAkMlkd5351fVdGKzL0PoblmWRm5uL1tZWvTqip6enIy4uDu+++y5WrVpF7wcy4JlEwNi1axeWLl2Kr776CpMmTcKWLVuQmJiIoqKi265ZPXXqFKZPn46NGzciNjYWP//8MzZt2oTMzExMmDChD55B31KpVHj22WeRmpqKffv2ITAw8I7HtrW14dChQ5BKpdi7dy9sbGwQFxcHsViMqKiobq/11Wq1qKur475wdSUghUIhHBwcBu2HcFlZGS5fvkzdoo2ktrYW58+fh7+/Pzw9Pbnb29vbuT1DCoUC9vb23FIW2jPUc62trcjIyIBAIKBlf3dw4zK+mpoadHR03NLFvrm5GW5ubgCuv4bvtJdDt8dlyJAhevVdIPeGZVnk5+ejqakJERERXYaL7OxsxMTE4K233sIrr7xC7wcyKJhEwJg0aRIiIyOxdetWANenLT09PbFq1Sq88cYbtxy/ePFitLa2Yu/evdxtkydPRkhICL766iujjbu/SE9Px8qVKyGVSrt1JV2pVOLIkSOQSqXYvXs3hgwZws1sTJs2rdtVYhiG6RQ2eDweN7Ph5OQ0KD6UdT1FqqurERISAgcHh74e0qCnmykaP348d7J2OyqVituzUV9f3+N186ZOt6do+PDhnarSkTtjWRYtLS3cvo2WlhY4OTnB0tISkydPBnB9Bu52n6lqtRqZmZmwtLSkggVGwLIs1zcnIiKiy9LWeXl5mD9/Pl555RWsXbuW3g9k0Bj0AUOlUsHGxgZJSUkQi8Xc7cuWLUNjYyN27959y328vLywZs0arF69mrtt/fr1SElJQU5OjhFG3f+wLHtPH3xqtRppaWlISkpCSkoKtFotYmJiIBaLMXPmzG73F2AYBg0NDZDJZFxFIN3MhjGaW/UGhmGQl5eHpqYmhIWF0RVyI6isrMSlS5e6PVN047r52tpaDB06lAsbg3lm7V4pFApkZmbCx8cHvr6+fT2cAUs3s3bx4kWIRCIAQE5ODtzc3Do1llSr1cjIyMDQoUMRHBw8ID8XBxKWZXHhwgXU19cjIiKiyyWVFy5cwPz58/H8889jw4YN9LlBBpVBv8m7trYWWq0WQqGw0+1CoRCFhYW3vU91dfVtj6+uru61cfZ39/rBZ2FhgTlz5mDOnDnYtm0bTp48icTERKxcuRKtra2IiYmBSCTCAw88oFfJRjMzMzg7O8PZ2ZmrcCWXy5Gfnw+tVsud7N1cfrS/UqvVXI30iRMn0sbiXsayLC5fvoyKigqEhYXB0dGxW/e3sLCAu7s73N3dOy3j022g1b3+BmrY7Q0NDQ3Izs7GqFGj4OXl1dfDGdCsra3h5eXV6XOipaUFZ86c4cKuk5MTiouLYW1tjaCgIHod9jKWZVFUVKR3uLh48SJiY2Px1FNPUbggg9KgDxik/xkyZAhmzpyJmTNn4vPPP8fp06chkUjw+uuvo76+HtHR0RCLxZg7dy6GDRvW5ePpKlzx+XyMGTMGCoUCcrkchYWFUKvVXK+D3uqke6+USiWysrIwdOhQhISEUE36XqY7EZDJZIiMjLznksg3Nu/TzazJ5XLk5eWBZVm4uLhwYbc/vv6MQbfHZfTo0d3uNk3ujGEYANc/U0NCQriwW11dzTXltLe3R11dHfh8vsm+/nqbbmlrTU2NXuHi8uXLiI2NxZIlS/DBBx9QuCCD0qA/k9GdVMpksk63y2SyO663dnNz69bxpOfMzc0xbdo0TJs2DR9//DHOnTsHiUSCDRs2YMWKFZgzZw7EYjHmzZvH1Xu/Gx6PB0dHRzg6OsLf3x/Nzc2QyWQoLi5GXl4e1+vAxcWlX5zIt7S0ICsrC3w+H2PHjqWrjL2MYRjk5+dDoVBg4sSJBu8kf+PMWkBAABd2L168CJVKxYWN/vL6Mwa5XI7c3FyMGzeuW52mSde0Wi2A/ytRa25uDkdHR5SUlEAgEGDEiBGora3lLrboNom7uLgM+E7p/QXLsiguLoZMJkNERESXnynl5eXc8uCPPvqIPvPJoDXo92AA1zd5T5w4EV988QWA6ycZXl5eWLly5R03ebe1teG3337jbpsyZQqCgoJMcpN3X9B1Pk1KSoJUKkVpaSlmz54NkUiEmJiYbq9z122SlMvlkMlkaG9vh7OzM1d+tC++bBsbG5GdnY0RI0Zg1KhRdBWrl2m1Wpw/fx5KpRJhYWHd3vdzL258/cnlcrS2tnZ6/Q3WJXG6DfSBgYF6d5km+istLcWECRNgY2PDVZrKyMiAnZ0dxo8fz528siyL5uZmbpN4a2sr+Hw+V5GKyi/3XHFxMa5evYqIiIguZ9yvXr2K6OhozJkzB9u3b6dwQQY1kwgYu3btwrJly/D1119j4sSJ2LJlC3799VcUFhZCKBRi6dKl8PDwwMaNGwFcL1M7Y8YM/Otf/0JMTAx27tyJDz74wGTL1PY1Xck/XdgoLCzErFmzIBaLERMTA2dn526fnLe2tkImk3EVWfh8PoRCodFO9nRLaG4ui0p6h1qtRnZ2NgAgJCSkz6/etra2cid7TU1NcHR05JZZDZaTvStXruDixYsIDg7Wq8M06b7i4mIEBwfD3t4eZWVlyMjIgL29fZcd6Nva2rjXn0KhgJ2dHff602dZKrmupKQEV65c0StcVFdXIzo6GtOmTcOOHTtouRoZ9EwiYADA1q1buUZ7ISEh+PzzzzFp0iQAwMyZM+Hj44OEhATu+MTERKxbt45rtPfhhx+adKO9/kK31lUikUAqlSInJwf33XcfRCIR4uLiIBAIuh022trauCvLTU1NXGM1gUDQK1e5dSdeEyZMoKu6RtDR0YHMzExYWVn1yzKdSqWSK73c0NAwKE72ysvLcfnyZYSEhMDJyamvhzNoFRYWIjw8HI6Ojvj111/h4OCA8ePHd+szUKVScWGjvr4eVlZW3OvPlBqbdldpaSnKy8sRERHR5T4uuVyO+fPnIywsDN9//73JLI8kps1kAgYZfHSVgCQSCZKTk3Hu3DlMmTIFcXFxEIlEGD58eLe/HHUne7rGag4ODlyvjXu9ssyyLEpKSlBZWUknXkbS1taGzMxMODo6dnlVtz+48WSvrq4ONjY23MmenZ3dgDjZ01XnCg0NpT4uvSw/Px8TJ06Eg4MDDh8+fM8d0TUaDerq6lBTU4OamhquIpqrqyv4fH6/f/8YS1lZGcrKyhAeHg47O7u7HltbW4uYmBgEBATg559/7vPZU0KMhQIGGRRYlkVlZSWkUimkUilOnTqFiIgIiEQiiMVieHl5dfuLt6Ojg5vZaGho4Lo4C4XCbm8OZhiGq48eGhp6z5WLSNd0Dd3c3NwwevToAXFyfiONRtOp14aFhQUXNhwdHfvd89Ftdr127RrCwsK6PPEi9+7cuXOYOXMmnJ2dUV5ebtDXhK4imi7warXaTpvETfUqfEVFBUpKShAeHt5l4ZGGhgbExsbC29sbv/76a68vvz1x4gQ2b96MjIwMVFVVITk5uVP/r5ulpaVh1qxZt9xeVVVFRW3IPaOAQQYdlmW5D1eJRII//vgDQUFBEIvFEIlEPdpQfXMXZ1tbW25mo6tlLDduLg4NDR00a+z7s8bGRmRlZcHb2xu+vr797mS8u7RaLerr6zt1sXd1de03jSV1pX/lcjnCw8MH7NKugaS9vR2//PILVq1aheHDh+PSpUu99rtYlkVTUxMXNtra2uDs7MxtEjdmwYS+VFlZieLiYoSFhXU5O6dQKLBw4UIIhUJIpVKj/I0OHDiAP//8E+Hh4XjwwQf1DhhFRUWdwpJAIOjzzxQy8FHAIIMay7Kora3lwsaxY8cQEBDAhY2AgIBun3yq1epOy1isra25sGFra9vp8VQqFbKysmBubo7g4GCaHjeCmpoa5ObmDtoN9AzDoLGxkQu8Wq2W6/XSF702WJZFQUEBGhoaEB4ebvDSv+RWbW1tyMjIgEwmw7Jly+Dl5YULFy4Y7fffXKRAN7srEAhgY2NjtHEYk27vnD6NOZubmyEWi2FnZ4c9e/b0yUUlHo+nd8BoaGjodrNRQrpCAYOYDF3H7927d0MikeDIkSMYOXIkt4zqxrKO+tItY5HJZKitreU2SAqFQpibmyM7Oxt2dnaYMGECXREyAl1Z1PHjx5vEFL/uyrJu31BHR0enXhu9HWgZhkFeXh5aWloQFhZGs3NGoAsXAoEA9fX1mD17Nnx9fZGXl9cn4+no6Oi0SVy3b8jV1XXQbBK/du0aCgsLERoa2uXeudbWVjz00EMwNzfH3r17+2w2rzsBw9vbGx0dHZgwYQI2bNiAqVOnGm+gZNCigEFMlkKhwG+//QapVIqDBw/Cw8ODCxshISHdDgRarZZbMy+Xy8EwDOzs7BAQENDtvh2k+yorK3Hp0iUEBQXBxcWlr4djdCzLcuWXa2pquPLLupM9Qy/R0C396+joQFhY2KDt5dGftLa2IiMjA0KhEKNHj8apU6cwd+5c+Pv7c2WY+9LN+4aGDBnCvf76w1K+nqiqqsKFCxcQEhICPp9/12Pb29vx8MMPQ6VS4cCBA326D0mfgFFUVIS0tDRERESgo6MDO3bswA8//IAzZ84gLCzMeIMlgxIFDEJwfUp7//79kEql2L9/P1xcXLBw4ULEx8cjMjKyW1+MdXV1yM7OhlAoBHB9yY65uTk3s9EfN+gOZLpqYrrKRTTVf93N5ZcdHBy4ZSz3uoxJq9UiOzsbWq0WoaGhtPTPCFpbW5Geng53d3f4+/uDx+PhxIkTmD9/PgICApCRkdHXQ+yEYZhO+4YYhuH2bLi4uPS7ctG3U11djYKCAr16uSiVSixZsgQKhQKHDh3q8wpq+gSM25kxYwa8vLzwww8/9M7AiMkwzTIQhNzEzs4Oixcv5rq4Hzp0CBKJBPHx8bC1tUVcXBzEYjGioqLu+sVYUlKCsrIyjBs3Du7u7gA6f9Hm5OSAx+NxJ3oD9apef3Hj5uLIyEiqznUDGxsb+Pj4wMfHp1NFtEuXLsHW1rZTr43uBF5d00Iej4ewsDCTrSZkTC0tLcjIyMDw4cPh5+fH/f/SaDQA0C8/Q8zMzODi4gIXFxewLAuFQoGamhoUFxcjLy+v0+xaf5z9kslkyM/P1ytcqFQqLF26FHV1dTh8+HCfh4t7MXHiRJw8ebKvh0EGAfpmIOQmNjY2iI+PR3x8PJRKJY4cOQKJRIIlS5bAwsICCxcuhFgsxrRp07grtwzDYP369dizZw9SU1M7LdG58Ys2ICCA26Cbl5cHlmU7bdDtjycK/RXDMMjPz4dCoUBkZCRtLr6LoUOHwtPTE56enp2KFJSWlnarsZpKpUJmZiYsLS0RHBw8IK5CD3S6cOHh4XFLBTytVgsA/T7k8Xg8ODo6wtHREX5+ftwm8StXruDChQsGnV0zBN3nsz7LLdVqNZYvX47KykocPXp0wPc3ys7O5i6OEXIv+venEiF9zMrKCrGxsYiNjYVarcaxY8eQlJSEp556ClqtlvvZr7/+iiNHjmDXrl13/UIyMzMDn88Hn8/HmDFjoFAoIJPJUFhYCI1G06fVgAYSrVaLnJwcqFQqREZGmkyZTEOwsLDA8OHDMXz48E77hjIzMzFkyBDuNejk5NTpZFbXEd3GxgaBgYEUho2gubkZGRkZ8PT0xKhRo275uS5gDKTPCh6PB1tbW9ja2sLX1xdKpZILvJcuXcKwYcO4sHFzVT5j0FWhCwwMhKur612P1Wg0eOaZZ1BcXIyjR492OdPR21paWlBcXMz9d2lpKbKzs8Hn8+Hl5YW1a9fi6tWr+O9//wsA2LJlC3x9fTF+/HgolUrs2LEDR48exe+//95XT4EMIhQwCNGThYUF5s6di7lz5+LLL7/EH3/8gZ07d+KJJ55AR0cHFixYgIaGBiiVSr2q6dx4VW/06NFcNaCLFy9CpVLBxcUFQqEQzs7O/f4KpTHplugAQHh4OK3/vwfm5uYQCoUQCoWdlvKdP38eALglLDY2NsjOzoaDg8OA6Ig+GOjChZeXF0aOHHnbYwbKDMbdWFlZdZpd0wXe8vJyrrmkq6srHB0de/11V1dXh9zcXIwfPx4CgeCux2q1Wjz//PPIy8vDsWPHujzeGNLT0zs1zluzZg0AYNmyZUhISEBVVRUqKiq4n6tUKrzyyiu4evUqbGxsEBQUhCNHjty2+R4h3UWbvE3Mtm3bsHnzZlRXVyM4OBhffPEFJk6ceNtjExIS8OSTT3a6bejQoVAqlcYYar/X2NgIsViM9vZ2rFu3DqmpqUhOTkZjYyOio6MhFosxd+7cbteFZ1kWLS0tkMlkkMvlaG9vN2rp0f5MdxXdysoKQUFBA+rK7UDCsiy3lK+6uhoqlQrW1tbw8/Mz6S7OxtLU1ITMzEyuUeSd7NmzB0uWLMHkyZORmppqxBH2vpubSwLgNon3xgxvfX09srOzMXbs2C6XCGm1Wvztb3/DyZMnkZaWBg8PD4OOhZDBgL4lTMiuXbuwZs0afPXVV5g0aRK2bNmC6OhoFBUV3fHqi729PYqKirj/pupH1125cgXz58+Hj48P9u3bh2HDhmHhwoX45JNPcPbsWUgkErz99ttYsWIF5syZA7FYjHnz5ulVtpDH48HOzg52dnbw8/NDS0sL5HI5ysrKkJ+fD2dnZ24JgSmFjba2NmRmZsLR0ZGuovcyHo8HJycnWFhYoKqqCm5ubrCyskJJSUmn16Crq6tJvQaNQaFQIDMzE76+vvDx8bnrsbpN3oMxaJubm3OBQhd4a2pqcPHiRa7fi+7n9/oabGhoQHZ2NgICAroMFwzD4JVXXsHx48dx7NgxCheE3AHNYJiQSZMmITIyElu3bgVw/YPS09MTq1atwhtvvHHL8QkJCVi9ejUaGxuNPNL+LT8/H/PmzcO8efOwffv2O17NZRgG2dnZSEpKglQqRXl5OWbPng2RSIQFCxb0qDdGW1sbN7PR3NwMJycnrot4f6zEYijNzc3IzMyEm5sbRo8eTUHXCHRX0T09PTFy5Ejub64LvHK5HC0tLXBycuICL+2FuTe6cDFy5Eh4e3t3eXxiYiKWL1+O6dOn48CBA0YYYd/TzfDq9m3oXoO6sNHdTeKNjY3IzMzE6NGjMWLEiLseyzAM3njjDezZswdpaWl3XLpGCKGAYTJUKhVsbGyQlJTUqS72smXL0NjYiN27d99yn4SEBDzzzDPw8PAAwzAICwvDBx98gPHjxxtx5P1PTEwMIiMjsX79er1PdFmWRV5eHpKSkpCcnIyioiLMmjULIpEIsbGx4PP53T5pbm9v5zo4NzU1wdHRkTvRG0wdlRsbG5GVlcWVXKVw0ft0f/OurqLrXoNyuRwKhQL29vbca7C7SwNNne5vPmrUKHh5eel1n19++QXPPPMMZs2ahb179/byCPun9vZ2Lmw0NjZ2qwSzLtD5+fnB09Pzrr+HYRi8/fbb2LVrF44dO4bRo0cb+qkQMqhQwDAR165dg4eHB06dOoWoqCju9tdffx3Hjx/HmTNnbrnP6dOnuc7ICoUCH330EU6cOIH8/Pwur/QMZiqV6p5mC3S9GyQSCaRSKc6fP4/77rsPYrEYCxcuhEAg6PZJtFKp5E70GhsbYW9vz81s9Ieyjz2lq+iiz9VFYhi6tej+/v5dnnTdqKOjgzvRq6+v7/NqQANJT8IFAPz444949tlnMWfOHKSkpPTeAAcIlUrFbRKvq6vD0KFDO20Sv/E12NTUhIyMDL3+5izL4v3338d3332HY8eOYezYsb39VPq1tLS0u24EnzlzJo4dO2bEEZH+iAKGiehJwLiZWq3G2LFjsWTJErz33nu9OVyToetCrQsb6enpmDJlCkQiEeLi4jB8+PBun5ipVCoubNTX18POzq7TFb2BoqqqCgUFBRg/fjzc3Nz6ejgmQRfoAgICMHz48B4/zo3VgGprazF06FAIhUK4urr2aGngYNbQ0ICsrKxuBzoA+P777/HCCy9g3rx5kEgkvTTCgUmr1aKurg41NTWoqakBj8fjllFZWlpyM3RdLUVjWRYffvghvvzySxw9ehSBgYFGegb9l0qlQn19/S2379mzB8899xx27dqFhx9+uA9GRvoT2uRtIlxcXGBubg6ZTNbpdplMpvfJm4WFBUJDQzvV2Sb3hsfjYdSoUXj99dfx2muvoaKiAlKpFFKpFH//+98RGRkJkUgEkUgELy8vvU7MLC0tMWLECIwYMYJrqiaTyVBSUsJdVRYKhf2663VFRQWKi4sREhLS57XlTYVMJkNeXh4mTJgAoVB4T49lYWEBd3d3uLu7cyd6crkcWVlZMDc35wKvMUqP9me62aKeztANxD4YxnLj64xhGG6TeEFBAVQqFWxtbWFpaQm1Wn3HTeIsy2LLli344osvkJqaSuHi/7O0tLzlvOHChQt49dVX8eabb1K4IAAoYJgMS0tLhIeHIzU1lduDwTAMUlNTsXLlSr0eQ6vVIjc3FwsWLOjFkZouHo8Hb29vvPzyy1i9ejWuXbuG5ORkSCQS/OMf/0BwcDDEYjFEIlGnTbd3c2NTtRuvKpeVlcHa2rpT2OgPV5V1MzqVlZUICwuDo6NjXw/JJFy7dg2FhYUICgrqsrlYd918otfQ0AC5XI7c3NxOnez5fL5JnSjrwsWYMWN6XIloMPTBMAZdg1NLS45YUUMAAD6HSURBVEtUVVVhxIgRsLS05Crz8fl8NDQ0wNfXl9u4zbIstm3bho8++giHDh1CaGhoHz+L/quxsREikQgzZ86k1Q2EQ0ukTMiuXbuwbNkyfP3115g4cSK2bNmCX3/9FYWFhRAKhVi6dCk8PDywceNGAMC7776LyZMnw8/PD42Njdi8eTNSUlKQkZGBcePG9fGzMR0sy0IulyMlJQUSiQRpaWkYO3YsFzbGjBnT7XCg0WhQV1cHmUyG2tpaWFpacns27O3t+yRs6PamyOVyhIWF9esZlsGksrISly5dQkhICPh8vtF+L8uyXCd7uVwOtVrdqd/LYD5prqurQ05Ozj0vRdu+fTteffVVPPjgg/jhhx8MOMLBp7W1Fenp6fDw8ICfnx93e1tbG2pqarB+/XpIJBKMHj0a0dHRGDJkCL799lscOHAAU6ZM6cOR928MwyA2NhZlZWU4c+aMXqXYiWkYvJ/g5BaLFy9GTU0N3n77bVRXVyMkJAQHDx7klkNUVFR0Wq7Q0NCAv/71r6iuroaTkxPCw8Nx6tQpChdGxuPxIBQK8eyzz2LFihWor6/H7t27IZVKsWnTJowaNQpxcXGIj4/Xuz/EkCFDuA7ONy5hyczMxJAhQzotYTFG2GAYBvn5+WhqakJkZOSA3pg+kJSVlaG0tLRPZotu7mSvay55+fJl5OXldeq1MZhKMNfW1uL8+fN6NXTrCi2R0k9bWxsyMjIwfPhwjBo1qtPPbGxs4O3tjYSEBPzzn/9EYmIivvvuOxQXF8PLywt79uyBubk5IiMjTXo53528+eabOH36NM6ePUvhgnRCMxiEDGCNjY347bffIJVKcejQIXh4eEAsFkMsFiM4OLjbX4gMw6C+vh4ymYzbGKlbRtVb6+W1Wi1ycnKgUqkQGhpKvRSM4OalaPb29n09pE5aW1u5QgXNzc2DpgSzIcMFAHz22Wd488038eijj+Lf//63AUY4+LS3tyM9PR0CgaDLHjosy+Lnn3/GmjVrsHPnTiiVSqSkpGDv3r2wtraGSCSCWCzGrFmzBlXo7amdO3fi8ccfx759+xAdHd3XwyH9DAUMQgaJ5uZm7N+/HxKJBAcOHICLiws3sxEREdGjsKFbLy+Xy8GyLHeSx+fzDRI21Go1srKywOPxEBISQl2hjYBlWVy8eBHV1dUIDw/v90vRbi7BPFCrotXU1OD8+fMGrYr28ccf4+2338Zjjz2Gb775xiCPOZjowoWrq2uXS0lZlkViYiJWrlyJpKQkzJs3j/uZWq3G8ePHkZKSgpSUFDQ3N+P06dMmPZufnZ2NqVOn4p133sGrr77a18Mh/RAFDEIGoba2Nhw8eBASiQT79u2DnZ0d4uLiIBaLMXny5G4vqWBZFo2Njdx6ea1WC1dXVwiFwh5vzu3o6EBmZiasra0RGBhIyzyMgGVZXLhwAXV1dQgPDx9wzfBUKhXXa6Ourg42Njb9rlDB7eg2tRuiQteNNm/ejA0bNmDZsmX48ssvDfa4g4FSqUR6ejqcnZ0REBDQ5WsjJSUFK1aswM6dOxEbG3vH41iWRXp6uklfEKmtrUVERATGjx9/25kzc3NzgxeLIAMP7cEgZBCysbHBgw8+iAcffBBKpRKHDx+GRCLB4sWLMXToUCxcuBBisRhTp07V60uSx+PByckJTk5OGDNmDBQKBeRyOQoLC6FWq7lKQLpyyF1pa2tDZmYmHB0d9d43Qu4NwzAoKCiAQqFARETEgNznYmlpCQ8PD3h4eECj0XBV0c6dOwdLS0su9PanXhu6cBEYGAiBQGDQx9ZoNABoD8bNOjo6kJGRAScnJ73Cxd69e/HXv/4VP/74413DBXD9szAyMtKQwx1w9u3bh/LycpSXl992qZ+3tzfKysqMPzDSr9AMBiEmRKVS4dixY0hKSsLu3bvBsixiYmIQHx+PGTNmdHtdMcuyaG5uhlwuh0wmg1KphIuLC4RC4R0rATU3NyMzMxNubm5drokmhsEwDHJzc9HW1oawsLBBt89Fq9Wivr4ecrm8094hgUAAJyenPguwut4ivREuAOD999/Hxo0bsWLFCnz66acGf/yBSKVSIT09Hfb29hg/fnyXny+HDh3CE088gX//+99YvHixkUZJyOBHMxiEmBBLS0tER0cjOjoa27dvx4kTJ5CUlITnn38e7e3tiImJgVgsxv3336/XZloejwd7e3vY29tj1KhRaG1thUwmQ2lpKVdfXtfB2cLCAg0NDcjOzoaPjw98fHwoXBjBjZvow8PDB+XmVN2SDFdXV66pmlwuR35+PrecTyAQwNnZ2WhX+6urq5Gfn98rvUV0qIpUZyqVChkZGbCzs9MrXBw7dgxPPPEEvvrqKzzyyCNGGiUhpoFmMAgh0Gq1+PPPPyGRSJCcnAyFQoF58+ZBLBZjzpw5PVqrr6sEJJPJ0NLSAltbW7S0tMDPzw8+Pj6GfxLkFhqNBtnZ2WBZ1iTXjOt6bei62Xd0dHTqtdFbf4+qqipcuHABQUFBcHFx6ZXfAQD/+Mc/8Mknn+DFF1/Ehx9+2Gu/ZyBQq9XIyMiAjY0NJkyY0OWs1R9//IFFixbhs88+w5NPPkkXOwgxMAoYhJBOGIbB2bNnkZSUhOTkZMhkMsydOxdisRjR0dE9qnVeXl6OS5cuwdraGu3t7XBycuKWsAy25Tr9ha5Cl7m5OUJCQkz+KjfLsmhpaeEqUrW2toLP53OvQ0PN7Oi6ogcHB8PZ2dkgj3knb775Jj777DO89NJL+OCDD3r1d/VnunBhZWWFoKCgLsPF6dOnER8fj02bNuG5556jcEFIL6CAQQi5I4ZhkJWVhaSkJEilUlRUVGD27NkQi8VYsGCBXl2/KyoqUFxczJ1w6cqOymQyKBQKODg4cJWABnKPg/5Et1SEKnTdWVtbGxc2mpqauNehQCDo8QZ4Y4YLAHj99dexbds2rFmzBu+9916v/77+SKPRIDMzExYWFnr1/jl37hxEIhHeffddrFq1isIFIb2EAgYhRC8syyIvLw+JiYlITk7GxYsXcf/990MkEiEmJgZ8Pr/TlzXDMFi7di1GjRqFxYsXw8HB4ZbH7Ojo4E7yGhoaYGdnB6FQCIFAMOBKqPYXSqUSmZmZsLW11WupCLn+N9OVv21oaICtrS0XNvTtE3L16lUUFRUhJCQEfD6/l0d83auvvort27fj9ddfx/r1643yO/sTXbgYMmQIQkJCunytZ2VlITY2Fm+99RZeeeUVCheE9CLa5E0I0QuPx0NgYCACAwPxzjvvoLCwEElJSfjmm2/wt7/9Dffddx/EYjEWLlwIPp+PZ555BkePHkVKSsptwwUADB06FJ6envD09OR6HMhkMhQXF3MneUKhcEA1VOtL7e3tXHnOcePG0QmUnqysrLjXoVqt5sJGaWkprK2tubBhZ2d327/plStXcPHiRaOGC8C0N3lrtVpuCaA+Mxe5ubmIi4vDa6+9RuGCECOgGQxCyD1hWRYlJSWQSCSQSqXIyMiAg4MDGIbBrl27MHXq1G5/md94kldXVwdra2tuZqM/N1TrS62trcjIyIBAIOiyazHRj0ajQV1dHVf+1sLCggsbjo6O4PF4qKysxKVLlxAaGgonJyejjm/VqlX4z3/+g3Xr1mHt2rVG/d19SavVcsULQkNDuwxYBQUFWLBgAV544QWsX7+e3huEGAEFDEKIwbS0tCAmJgYlJSVwd3dHVlYWJk6cCJFIBJFIBE9Pz25/ud/YUK2mpgZWVlbczMadriibGl1vkeHDh8PPz4/+Jr2AYRiu14ZcLgdwvaFlc3MzQkNDjTpzofPCCy/g+++/x4YNG/Daa68Z/ff3BV3ZZa1Wi9DQ0Nv22rnRxYsXMX/+fCxfvhwffPABvTcIMRJanEtM0okTJ7Bw4UIMHz4cPB4PKSkpXd4nLS2Na1Lm5+eHhISEXh/nQFJfX4+5c+fCzMwMBQUFOHv2LMrLy7FkyRIcPHgQgYGBmDlzJj799FNcvnwZ+l7bGDJkCNzc3BAUFISZM2fC398fSqUS6enpOHnyJIqKitDY2Kj34w02CoUC6enp8PLygr+/P51A9RIzMzO4uLhg3LhxmD59OoRCIZqammBubo6cnBzk5uZCJpNxy5aMQdfJ21T22TAMg/Pnz0Oj0egVLkpKShAbG4u//OUv+Oc//0nvDUKMyDQ+lQi5SWtrK4KDg7Ft2za9ji8tLUVMTAxmzZqF7OxsrF69Gs888wwOHTrUyyMdGK5du4YZM2ZAIBDgwIEDXHUpDw8PrFq1CkePHkVlZSWefvppHD9+HGFhYZg6dSo2bdqEoqIivcOBubk5BAIBF1YCAgKg0WiQlZWFP/74A4WFhaivrzeZsNHQ0IDMzEyMGjUKvr6+fT0ck1FRUYHq6mpERkZixowZCAsLg5WVFYqLi5GWlobs7Gxcu3YNarW6V8ehCzNdnWgPBrpwoVKp9AoXZWVliI2NhVgsxubNm00mhBHSX9ASKWLyeDwekpOTIRaL73jM3//+d+zbtw95eXncbY8++igaGxtx8OBBI4yy/6qqqsLUqVMxY8YMfPvtt11+8bMsi/r6euzevRsSiQRHjhyBv78/4uLiEB8fj7Fjx3b7ZIBhGDQ0NEAmk0Eul4PH48HV1RVCoRBOTk6D8uSirq4OOTk5GD16NEaMGNHXwzEZpaWlKCsrQ3h4OOzt7W/5+Y29NlpaWnq158vy5cuRmJiITZs2YeXKlQZ97P6EYRjk5uaivb0d4eHhXTZIvHr1KubOnYu5c+di+/btg/L9T0h/N/gvexBiAKdPn8bs2bM73RYdHY3Vq1f3zYD6EYFAgA0bNuDxxx/X64ucx+PB2dkZTz31FJ588kkoFArs2bMHUqkUW7ZswYgRIyASiRAfH69X0yzg+hIRZ2dnODs7Y+zYsWhoaIBcLkdeXh5YloWrqysEAgGcnZ0HxcmGXC5Hbm4uxo0bB3d3974ejskoLS1FeXn5HcMFANja2sLW1hYjR45Ee3s75HI5qqurUVRUBHt7ey5sGKIMsylUkWIYBnl5eWhra9MrXFRXV2PBggWYOXMmvvzyy0HxfidkIKKAQYgeqqurIRQKO92mW4Pd3t7e48Zcg4G5uTmWLl3ao/vyeDw4Ojpi6dKlWLp0KZqbm7Fv3z5IJBLMnTsXrq6uEIlEEIvFiIiI0DvA8Pl88Pl8jBkzBgqFAjKZDIWFhdBoNHBxcYFQKISzs/OAPDGrqqpCQUEBAgMDIRAI+no4JqOkpASVlZUIDw/Xu5u9tbU1vL294e3tjY6ODq4yWnFxMYYNG9apDHNP9gcM9iVSLMuioKAALS0tiIiI6LLbulwuR0xMDCZOnIgdO3YMyPc3IYPF4PxUIoQMSHZ2dnj00Ufx6KOPorW1FQcPHoREIoFIJIKDgwPi4uIgEokwefJkvU4edAHG0dERo0ePRlNTE+RyOS5evAiVSgUXFxcIBAK4uLgMiJO0G/stGKNTNLl+knv58mVUVlYiIiJC78Z7Nxs6dChGjBiBESNGQK1Wc5XRysrKuMpoAoGA27+kD90m78F4Iq0LFwqFQq9wUVtbi4ULFyIwMBDff//9oPybEDKQ0NwhIXpwc3ODTCbrdJtMJoO9vb1Jz170pmHDhuGhhx7Czz//jOrqamzduhUtLS1YvHgxRo8ejZdffhnHjx/nTrK6wuPx4ODgAH9/f0ydOhWRkZGwsbHB5cuXcfz4cWRnZ6OqqqrXN+b2VEVFBddvgcKFceh6vFy5cuWewsXNLCws4O7ujuDgYK4yWkdHBzIzMzsVK2AY5q6PM1iXSLEsiwsXLqChoQHh4eFd7l1paGiASCTCqFGj8OOPPxrlYgFVIiTk7vr/JTtC+oGoqCjs37+/022HDx9GVFRUH43ItFhbWyMuLg5xcXFQqVQ4evQoJBIJli5dCh6Ph5iYGMTHx2P69OldXukErocNOzs72NnZwc/Pj9uYW1ZWhvz8fDg7O0MgEMDV1VWvx+tturX/YWFhd+yKTgyLZVkUFxfj2rVriIiI6LVu8rrKaAKBoFOxgtzc3E77h/h8/i1BYjAGDJZluYAVEREBKyurux6vUCggEokwfPhw7Nq1y2jvV10lwqeeegoPPvhgl8frKhE+99xz+Omnn5CamopnnnkG7u7uiI6ONsKICTEuqiJFTFJLSwuKi4sBAKGhofjkk08wa9Ys8Pl8eHl5Ye3atbh69Sr++9//Arj+5TBhwgS8+OKLeOqpp3D06FH87W9/w759++jLoQ9pNBqcOHECiYmJSElJQUdHB2JiYiAWizFr1qwuT05up62tDXK5HDKZDM3NzXBycoJQKISrq6vBqwB15caT3LCwML3X/pN7w7IsLl26hOrqaoSHh/dauOhqDI2NjVxFKrVafcuSvtjYWBw7dgw7duzAkiVLjD5GQ2NZFhcvXoRcLkdERESXs8PNzc0QiUSwt7fHnj17evR+NwSqREjIrWgGg5ik9PR0zJo1i/vvNWvWAACWLVuGhIQEVFVVoaKigvu5r68v9u3bh5dffhmfffYZRowYgR07dlC46GNDhgzB/fffj/vvvx9bt27Fn3/+iaSkJKxevRpNTU2YP38+xGIxZs+erXfVHhsbG/j4+MDHx4erAlRVVYXCwkI4ODhAKBRCIBD0+skMy7IoKiriTrb64iTXFOlOcmUyWZ+FC+D6SauTkxOcnJwwevRoNDc3Qy6X4/Lly8jPzwefz0d7ezuAwbHJWxfqZDKZXuGitbUVixYtgrW1NZKTk/ssXOiLKhESU0MzGISQQYdhGJw5cwZJSUlITk6GXC5HdHQ0RCIR5s2b16O19EqlEjU1NZDJZGhsbORKjgqFQoPvw9FtcNWtQad9PsahC3U1NTUIDw83SCnZ3tDa2gq5XI4lS5YgNzcX77zzDh555BGjBN/eoNvrcvXqVb3CdHt7OxYtWgSNRoMDBw4YbG9MT+kzgzF69Gg8+eSTWLt2LXfb/v37ERMTg7a2NnqPk0Fn4F/2IISQm5iZmSEqKgpRUVHYvHkzMjMzkZSUhPfffx/PPfccZs+eDZFIhAULFuhdtcfKygqenp7w9PSESqXilq4UFxfD1taWm9m41yveurr/utKcA/GEcSDSrf2vra3V6wp6Xxo2bBh8fX2515qTkxNXHU0XfF1dXQfMrNfly5f1DhdKpRJLliyBUqnEwYMH+zxcEEJujwIGIWRQMzMzQ0REBCIiIvDBBx8gLy8PSUlJ+PTTT/HCCy/g/vvvh0gkQmxsLJycnPQKG5aWlp1KjupmNkpKSu6pv4FWq8X58+fR0dGhV2lOYhi6qkW6jcX9OVzcSLfJ283NDREREVCpVLfttSEQCGBra9ujXhu9rbS0lCsB3FW46OjowBNPPIH6+nocPnx4QBU8oEqExNRQwCCEmAwzMzMEBQUhKCgI77zzDgoLC5GUlISvv/4af/vb3zB9+nSIxWIsXLgQLi4uep2QWVhYYPjw4Rg+fDg0Gg13gqfrb6Cb2bCzs7vr42m1WmRnZ0Or1erVsZgYxo3hYqAtR7u5D4alpSU8PDzg4eEBjUbD9do4d+4cLC0tubDh4ODQL8JGWVkZ1xm9q5kItVqN5cuX4+rVq0hNTYWTk5ORRmkYVImQmBrag0EIMXm6NeBJSUmQSqXIysrClClTIBaLERcXBzc3t26fkGm1WtTW1kImk6G2tpY7wRMKhbcsy1Kr1cjOzgaPx0NISMig2LQ7ENy412UgLkeLiorC+fPnkZKSgjlz5tzxOK1Wi7q6Oi78mpmZcWHDyckJZmbGb4lVXl6Oy5cvIzw8HPb29nc9VqPR4Omnn8aFCxdw9OjRftHBnioREnJ3FDAIIeQGLMuivLwcEokEUqkUZ86cwaRJkyASiSASiTBixIgehY26ujrI5XLU1NRgyJAh3AmejY0NsrKyYGlpieDg4EHV06A/Y1kW+fn5UCgUCA8PH3DhAgAiIyNRUFCA3377Dffff79e99H12tDtIWIYhuu14ezsbJTXX2VlJYqLi/Xq66LVavHcc88hMzMTx44dg5ubW6+PTx9paWmdKhHq6CoRLl++HGVlZUhLS+t0n5dffhkFBQUYMWIE/vGPf2D58uXGGzQhRkQBgxBC7oBlWVy9ehVSqRRSqRR//vknQkNDubDh6+vb7bDBMAzq6+u5XhtarRZWVlYICAgAn8/vk6vJpoZhGOTn56O5uVmvTtH9VXh4OAoLC3HgwAFMnz692/dnWRYKhYILGx0dHZ16bfTGMr0rV65wHekdHR3veqxWq8WqVavw559/Ii0tDR4eHgYfDyGkd1DAIIQQPbAsC5lMhuTkZEilUqSlpWHChAlc2Bg9enS3woZSqUR6ejqsra1hbW2NmpoarnOzUCiksNFLbqzSNZDDBQCEhITg0qVL+P333zF16tR7eiyWZbmO9nK5HK2treDz+dxMmyEKDly9ehVFRUUIDQ3tcg8FwzB4+eWXkZqaimPHjsHb2/uefz8hxHgoYBBCSDexLIu6ujrs3r0bEokEqamp8Pf3h0gkQnx8PMaOHXvXsNHS0oKsrCw4Oztzx97YuVk3s2HspSuDnS5ctLa2Ijw8fMBX6ZowYQJKS0uRmpqKyZMnG/SxdR3t5XI5mpqauCaTrq6uPdoIX1VVhQsXLiAkJAR8Pv+uxzIMg7///e/47bffkJaWhpEjR/b0aRBC+ggFDEIIuQe6ZSZ79uyBRCLB77//Di8vLy5sBAYGdpqJSE9Px9KlS/H1119j2rRptw0iLMuiqakJMpkMcrkcKpUKLi4uEAqFcHFxobDRAwzDIDc3F21tbYMiXADA2LFjUVFRgePHjyMiIqLXfo+uyaRcLkdDQ0O3+75UV1ejoKAAwcHBcHZ2vuuxDMPgH//4B3799VekpaXB39/fUE+DEGJEFDAIIcSAmpqasG/fPkgkEhw8eBACgQAikQhisRhKpRKPPPII/vKXv2Dz5s16LYFiWRbNzc3czIZSqeTWybu6ulLFKT0wDIPz589DqVQiLCxsUIQLAPD398e1a9dw8uRJhIaGGuV3qlQqrvxtXV0drK2tuWVUtyvFLJPJkJ+fj6CgILi4uNz1sVmWxXvvvYeEhAQcO3YMY8eO7c2nQgjpRRQwCCGkl7S2tuLAgQOQSqXYvXs32tvbERoaik2bNmHSpEndnolgWRatra3czEZbWxv4fD63dIV6Z9yKYRjk5OSgo6Nj0PUXGTlyJGQyGU6dOoXg4GCj/36NRoO6ujquFLOFhQUXNhwdHVFTU4Pc3FwEBQXB1dX1ro/Fsiw2bdqE7du34+jRowgMDDTSsyCE9AYKGIQQAMCJEyewefNmZGRkoKqqCsnJyRCLxXc8/k5lGquqqvpNKcn+4ujRoxCJRPjLX/4CpVKJ3377DVZWVli4cCHi4+MxZcqUHs1EtLa2cjMbLS0tBt+UO9DpOqOrVCqEhYUNqnABAN7e3qitrcXZs2cxfvz4Ph0LwzCdSjGzLAuNRgNfX1+MHDnyrrN1LMtiy5Yt+OSTT5CamoqQkBDjDZwQ0itobp0QAuD6yWpwcDCeeuopPPjgg3rfr6ioqFOjrP7QBKs/2bdvHxYvXoxt27Zh2bJlAK4vMzly5AikUimeeOIJ8Hg8xMbGIj4+Hvfdd5/e4WDYsGHw9fWFr68v2tvbIZPJcO3aNRQWFsLR0ZGb2RiIPR7ulVarRU5ODjQazaAMF8D15wigX+zJMTMzg6urK1xdXVFbW4ucnBw4Ozvj2rVrqKys5Jb1OTg4dHo9siyLbdu24aOPPsLvv/9O4YKQQYJmMAght+DxeHrPYDQ0NHRZz95UJSYmYvny5UhISMDDDz9822PUajVOnDiBxMRE7N69Gx0dHYiNjYVYLMasWbN6VEZVqVRyMxsKhQIODg7czEZPKgANNFqtFtnZ2dBqtQgLCxu0+1Tc3d3R1NSEnJwc+Pn59fVwAAD19fXIzs7G2LFj4e7uzhUskMvlqKiowGOPPYbQ0FAsXLgQixYtQkpKCtavX48DBw5gypQpfT18QoiBUMAghNyiOwHD29sbHR0dmDBhAjZs2HDP9fgHi7S0NMTGxmLXrl2IiYnR6z5arRYnT55EUlISUlJS0NzcjPnz50MsFmP27Nk9CgcdHR2oqamBTCZDQ0MD7OzsuApANjY23X68/k4XLhiGQWho6KANFwDg6uqKtrY25OXlwdfXt6+Hg4aGBmRlZSEgIADDhw+/5ecMwyArKwu//vorDh48iMuXL4PH4+Gll17Ca6+9RksrCRlEKGAQQm6hT8AoKipCWloaIiIi0NHRgR07duCHH37AmTNnEBYWZrzB9lNqtRq5ubk9/lswDIP//e9/XNioqalBdHQ0RCIRoqOjYWtr2+3HVKlUXLnRuro6DBs2jAsbPXm8/kaj0SA7Oxssyw76cAEAfD4fHR0duHDhAry8vPp0LI2NjcjMzMSYMWO67LjNsix++uknrF69GsuXL0dubi5Onz6NyZMnIz4+HvHx8dT7gpABjgIGIeQW+gSM25kxYwa8vLzwww8/9M7ATBTDMMjIyIBEIoFUKsWVK1cwZ84ciEQizJ8/Hw4ODt1+TLVajdraWshksk7lRoVCIWxtbbvVlbw/0Gg0yMrKAo/HQ2hoaL/Yl9DbHBwcoNFocOnSpdvOGBiLQqFAZmYm/Pz84OnpeddjWZZFYmIiVq5cCYlEgujoaADXe2Xs3r0bycnJOHr0KMaPH4/4+Hi89dZbJvH/kpDBhgIGIeQWPQ0Yr732Gk6ePInTp0/3zsAI1zAuKSkJUqkUJSUluP/++yESiRATEwMnJ6duhwONRsP1NqitrYWlpSU3s2Fvb9/vw4YuXJiZmSEkJMRkTkh1Te5KSkr6bHmRLlyMGjVKr1mU5ORkrFixArt27UJsbOxtj2loaMC+ffuQkZGBTz/91NBDJoQYAQUMQsgtehow5syZAzs7O0il0t4ZGOmEZVlcuHCBCxsFBQWYMWMGxGIxYmNj4eLi0u1woNVqO/U2GDJkCDez4eDg0O/ChlqtRlZWFoYMGYLg4GCTCRcMw8DOzg4AUF5e3mUTu97Q3NyM9PR0jBw5Et7e3l0ev3fvXjz55JP48ccfER8fb4QREkL6CgUMQggAoKWlBcXFxQCA0NBQfPLJJ5g1axb4fD68vLywdu1aXL16Ff/9738BAFu2bIGvry/Gjx8PpVKJHTt24IsvvsDvv/+OBx54oC+fikliWRbFxcVc2MjOzsbUqVMhFosRFxcHoVDY7XBwc28DMzMzrhpVT2ZKDE2tViMzMxMWFhYmFS6A6/tpnJycAABXrlzh/t1YmpubkZGRAW9vb702mB88eBBPPPEEvvvuOzzyyCNGGCEhpC9RwCCEALhz47xly5YhISEBy5cvR1lZGdLS0gAAH374Ib755htcvXoVNjY2CAoKwttvv33bxyDGxbIsysrKIJFIkJycjDNnzmDy5MkQiUQQiUTw8PDoUdhoaGiATCbjGqnpZjacnJzu2kitN6jVamRkZGDo0KEIDg42+u/va+3t7dysRVVVVadeNL2tpaUF6enp8PLy0msz9tGjR/Hoo4/iq6++wmOPPdbnwZQQ0vsoYBBCyCDGsiyuXr0KqVQKiUSCU6dOISwsjAsbPj4+3T7hY1kWDQ0NkMvlkMvl0Gq13MyGs7Nzr5/sq1QqZGZmwsrKCkFBQSYXLoDrJ/lCoRAAUFNTY7SSw62trUhPT4eHh4devTdOnDiBhx9+GJ9//jmWL19O4YIQE0EBgxBCTATLsqiurkZKSgokEgmOHz+OwMBALmz4+/v3KGwoFArIZDLI5XJoNBq4uLhAKBTC2dnZ4MuWVCoVMjIyYGNjg8DAQJMMF8D1srC6crD19fU9asjYXW1tbUhPT4e7uzv8/Py6fK2cPn0a8fHx+PDDD/Hss89SuCDEhFDAIIQQE8SyLOrq6rB7924kJSXh6NGjGD16NEQiEcRiMcaOHdujsNHc3MyFDaVSCVdXVwgEAri4uNxzXwoKF/+nrq6Oq9rU1NTU6/tP2tvbkZ6eDoFAgNGjR3f52jh37hxEIhHee+89rFy5ksIFISaGAgYhhJg4lmXR2NiIPXv2QCKR4PDhw/D29ubCRk9O5lmWRUtLC+RyOWQyGdrb2+Hs7AyBQABXV1dYWFh06/E6OjqQkZEBW1tbTJgwwaTDBQDIZDJu/0NLS0uvnsDrwoWrqyvGjBnT5e/KyspCbGws1q1bhzVr1lC4IMQEUcAghBDSSVNTE/bu3QuJRIKDBw/Czc2NCxthYWE9OrlvbW3lZjZaWlrA5/MhFArh6uoKS0vLu95XFy7s7Owwfvx4kw8XwPWN3X5+fjAzM0Nzc3Ov/R6lUon09HQ4OzsjICCgy7CQm5uLBQsW4NVXX8Ubb7xB4YIQE0UBgxBCyB21tLTgwIEDkEql2LdvH5ycnBAXFwexWIyJEyf2aGlOW1sbN7PR3NwMJycnbpP4zXsJlEolMjIy4ODggPHjx9MJ6/935coVjBkzBpaWlmhoaOiV39HR0YH09HQ4OTnptWSuoKAA8+fPx4svvoj169fT/ytCTBgFDEIIIXppb2/H77//DolEgr1798La2hoLFy6EWCzGlClTerTHor29natGpVAo4ODgwHURB4CMjAw4Ojpi3LhxdMJ6g7KyMowfPx7W1taora01+OPrZo3s7e31CnZFRUWYP38+nnrqKfzzn/+k/1eEmDgKGIQQQrqto6MDqampkEgk2L17N8zNzREbG4v4+Hjcd9993d5joXtMXdjQXZW3s7NDYGCg0cqwDhQlJSUICgqCnZ0dqqurDfrYus30uv0uXYWFkpISzJs3D48++ig2b95MS9gIIRQwCCGE3Bu1Wo3jx48jKSkJKSkpUKvViI2NhUgkwqxZs7pdQlW3qdjKygrm5uaor6+Hra0tN7MxbNiwXnomA0dRURHCwsLg6OiIq1evGuxx1Wo10tPTMWzYML0205eVlWH+/PmIi4vDZ599RuGCEAKAAgYhhBAD0mq1+OOPP7iw0dLSggULFkAkEmH27Nmwtra+6/114cLFxYXbVKxWq1FTUwOZTIb6+nrY2NhwXcSHDRtmkstxCgoKEBkZCWdnZ1RUVBjkMXXd0a2trfWqHHblyhVER0cjOjoaX375JYULQgiHPg0IMSFarRZTpkzBgw8+2Ol2hUIBT09PvPXWW300MjJYmJubY+bMmdi6dSvKy8uxb98+uLm54Y033oCPjw+WLVsGqVSK1tbWW+5bUFCAmJgY2NjYdKpYZGFhgeHDhyM0NBQzZsyAr68vWlpacObMGZw6dQrFxcVoamqCKV0v02q1AGCw/hcajQaZmZkYOnSoXuGiqqoKMTExmDVrFrZt20bhghDSCc1gEGJiLl68iJCQEHz77bd47LHHAABLly5FTk4Ozp0712XJUEJ6gmEYpKenQyKRIDk5GVevXsWcOXMgEokwf/58VFRUICYmBnPnzsXXX3+t1wmrVqtFbW0t5HI5ampqYGlpyVWjcnBwGNQzG1lZWZg2bRrc3d1RXFx8T4+lCxdDhgxBSEhIl397mUyG+fPnIyIiAt9//32vN/kjhAw8FDAIMUGff/45NmzYgPz8fJw9exYPP/wwzp07h+Dg4L4eGjEBDMPg/PnzSEpKglQqRXFxMXg8HiIjI/HLL7+Az+d3OxxotVrU19dDJpOhpqYG5ubm3DIqR0fHQRc2MjIyMH36dHh6eqKwsLDHj6PVapGZmQkzMzOEhIR0GRZqa2uxYMECjB8/Hj/99NM9d2cnhAxONKdJiAlatWoVgoOD8cQTT2DFihV4++23KVzcxsaNGxEZGQk7OzsIBAKIxWIUFRV1eb/ExEQEBATAysoKgYGB2L9/vxFGO3DoTmbff/99SCQSODo6IiIiAs3NzRg1ahTi4+ORkJCA2tpavZc9mZubw9XVFRMmTMCMGTMwbtw4MAyDnJwcnDhxAhcuXEBdXR0YhunlZ2ccGo0GwL0tkdJqtcjKygKPx9MrXNTX1yMuLg7+/v748ccfjRoutm3bBh8fH1hZWWHSpEk4e/bsHY9NSEgAj8fr9I+VlZXRxkoIoYBBiEni8XjYvn07UlNTIRQK8cYbb/T1kPql48eP48UXX8T//vc/HD58GGq1GnPnzr3t/gGdU6dOYcmSJXj66aeRlZUFsVgMsViMvLw8I458YCgoKMCsWbOwYsUKnDx5EtnZ2cjLy8PMmTPx3XffYdSoUYiNjcU333yD6upqvcOGmZkZXFxcMG7cOEyfPh2BgYEAgLy8PJw4cQL5+fmora0d0GHjXvdgaLVaZGdng2VZvcKFQqGAWCyGh4cHdu7c2aMyxD21a9curFmzBuvXr0dmZiaCg4MRHR0NuVx+x/vY29ujqqqK+6e8vNxo4yWE0BIpQkzW66+/zm3OzM3NhY+PT18Pqd+rqamBQCDA8ePHMX369Nses3jxYrS2tmLv3r3cbZMnT0ZISAi++uorYw2138vLy8MDDzyA559//rZdn1mWRVlZGSQSCaRSKc6ePYuoqCjExcVBJBLBw8Oj28ueWJaFQqGATCaDXC6HRqOBq6srBAIBnJ2dB9Regj/++APz5s3DmDFjkJmZ2a376mZ21Go1wsLCupyJaG5uhkgkgr29Pfbs2WP02YBJkyYhMjISW7duBXB9/J6enli1atVtL44kJCRg9erVaGxsNOo4CSH/h2YwCDFBp06dwqeffoq9e/di4sSJePrpp02qAk9PKRQKAACfz7/jMadPn8bs2bM73RYdHY3Tp0/36tgGkvz8fMyaNQsvvvgiNmzYcNugwOPx4Ovri1dffRV//vknSktLsWjRIuzduxfjxo3DAw88gM8++wxlZWV6v3Z5PB4cHR0xZswYTJs2DWFhYRg6dCguXryI48eP4/z585DJZNzsQH+mWyLV3epNuv0vKpUKoaGhXYaL1tZWLFq0CDY2NkhJSTF6uNA1/bvxPWVmZobZs2ff9T3V0tICb29veHp6QiQSIT8/3xjDJYT8fxQwCDExbW1tWL58OZ5//nnMmjUL//73v3H27Fm6ut4FhmGwevVqTJ06FRMmTLjjcdXV1RAKhZ1uEwqFBu+2PJC5uLjg/fffx9tvv63X8TweD56ennjppZeQlpaGyspKLF26FEeOHEFwcDCmT5+Ojz76CJcuXepW2HBwcIC/vz+mTp2KyMhI2NjYoKSkBGlpacjJyUFVVRV3It/f6EJQd/ZBMAyD3NxcKJVKhIWFdbnMqa2tDY888gh4PB727NnTJ93Ua2trodVqu/WeGjNmDP7zn/9g9+7d+PHHH8EwDKZMmYIrV64YY8iEEFDAIMTkrF27FizL4l//+hcAwMfHBx999BFef/11lJWV9e3g+rEXX3wReXl52LlzZ18PZcATCoV49tlne3RfHo8Hd3d3vPDCCzhy5AiuXbuG559/HqdOncLEiRMRFRWFjRs3oqCgoFthw87ODn5+fpgyZQomTZoEW1tblJWVIS0tDVlZWbh27RrUanWPxtwburvJm2EY5OXloa2tTa9woVQqsWTJEiiVSuzduxe2trb3PGZjiYqKwtKlSxESEoIZM2ZAKpXC1dUVX3/9dV8PjRCTQQGDEBNy/PhxbNu2Dd99912nq5HPPvsspkyZQkul7mDlypXYu3cvjh07hhEjRtz1WDc3N8hksk63yWQyuLm59eYQTRKPx4OrqyueeeYZHDhwAFVVVVizZg1ycnJw3333ISIiAu+++y7Onz/frQ3dtra2GDVqFKKiohAVFQVHR0dUVlbi+PHjyMzMxJUrV6BSqXrxmXVN93z0CRgsyyI/Px8tLS0IDw/vstdNR0cHHn/8cTQ2NmL//v2wt7c3yJh7wsXFBebm5vf0nrKwsEBoaOg99wshhOiPAgYhJmTGjBnQaDSYNm3aLT87dOgQUlNTB12/gHvBsixWrlyJ5ORkHD16FL6+vl3eJyoqCqmpqZ1uO3z4MKKionprmATXwwafz8fy5cuxZ88eVFdXY926dbh06RIeeOABhISEYN26dcjIyOhW2Bg2bBh8fX0xadIkTJ06Fc7Ozrh27RpOnDiB9PR0VFRUQKlU9uIzuz19l0ixLIuCggI0NzfrFS7UajWWL1+Oa9eu4eDBg3BycjLYmHvC0tIS4eHhnd5TDMMgNTVV7/eUVqtFbm4u3N3de2uYhJCbUIccQgi5gxdffBE///wzdu/eDTs7O27Nt4ODA6ytrQFc74Lu4eGBjRs3AgBeeuklzJgxAx9//DFiYmKwc+dOpKen45tvvumz52GKHBwc8Nhjj+Gxxx5DS0sLDhw4AIlEgpiYGPD5fCxcuBDx8fGIjIzUe5mRtbU1vL294e3tDaVSCblcDrlcjosXL8Le3h5CoRACgYB7bfQmfZZIsSyLCxcuoLGxEeHh4Rg6dGiXj/n000+jpKQEx44dg7Ozs0HH3FNr1qzBsmXLEBERgYkTJ2LLli1obW3Fk08+CeDW9+C7776LyZMnw8/PD42Njdi8eTPKy8vxzDPP9OXTIMSkUMAghJA72L59OwBg5syZnW7/7rvvsHz5cgBARUVFp0o+U6ZMwc8//4x169bhzTffhL+/P1JSUu66MZz0LltbWzz88MN4+OGH0dbWht9//x0SiQQPPfQQbGxsEBcXB7FYjKioKL03TVtZWcHLywteXl5QqVSQy+WQyWS4dOkS15hRKBT22sbormYwWJZFYWEh6uvrERER0WX1J61Wi+eeew4FBQU4evQoXF1dDT7mnlq8eDFqamrw9ttvo7q6GiEhITh48CC38fvm92BDQwP++te/orq6Gk5OTggPD8epU6cwbty4vnoKhJgc6oNBCCHEJCmVSqSmpkIikWDPnj0wNzfnZjamTZvWo2ZyKpUKNTU1kMvlqKurw7Bhw7iZDUNulN65cyeefvppzJw5E/v27ev0M5ZlcfHiRcjlckRERHQ5o6LVarFq1SqcOnUKx44dg4eHh8HGSQgxTTSDQQghxCRZWVkhJiYGMTExUKvVSEtLQ1JSEp5++mloNBrExsZCJBJh5syZXS4v0rG0tISHhwc8PDygVqtRW1sLuVyO0tJSWFtbczMbtra297Tf6U6dvFmWxaVLlyCTyfQKFwzDYM2aNThx4gTS0tIoXBBCDIJmMAghhJAbaDQanDx5EklJSUhJSUFLSwtiYmIgEonwwAMP9GiPhUajQV1dHWQyGWpra2FpacnNbNjb23c7bCQlJeH111/H9OnTkZCQAOB6uCgpKcHVq1e5vh53wzAM/v73v+O3335DWloaRo4c2e3nRQght0MBgxBCCLkDrVaL06dPQyKRIDk5GfX19YiOjoZYLMbcuXMxbNiwHj1mXV0d5HI5ampqMGTIEG5mw8HBocczGyUlJbhy5QoiIiK6HBfDMFi3bh0SExORlpYGf3//Hv1OQgi5HQoYhBBCiB4YhkF6ejqSkpKQnJyMa9euYc6cORCLxZg3b16P+kUwDIP6+nrIZDLU1NSAx+NxMxuOjo6dNi/fzeXLl1FRUYGIiIgu93qwLIt3330X33//PdLS0hAQENDtcRNCyN1QwCCEEEK6iWEY5OTkcGHj8uXLmD17NkQiEWJiYno0E8EwDBoaGrjytyzLQiAQQCAQgM/n3zFslJWVoaysDOHh4bCzs7vr72BZFv/617/w1Vdf4dixY1TdjBDSKyhgEEIIIfdA1ylbFzYuXLiAWbNmQSwWIyYmBs7Ozt0OGyzLorGxETKZDHK5HFqtFq6urhAKhXB2dubCRnl5OS5fvozw8PAuZ1BYlsWnn36KTz/9FKmpqQgJCenpUyaEkLuigEEIIYQYiK5ErEQigVQqRU5ODu677z6IRCLExcVBIBD0KGwoFAqu14ZarYarqyvMzc1RXV2N8PBwODg4dPkYW7duxaZNm3Do0CFERkbey9MkhJC7ooBBCCGE9AKWZVFaWsqFjXPnzmHKlCmIi4uDSCTC8OHDexQ2mpubUVxcjLq6OpiZmcHFxQVCoRAuLi63bbzHsiy++eYbvPPOOzhw4ACioqIM9RQJIeS2KGAQQgghvYxlWVRWVkIqlUIqleL06dMIDw+HSCSCWCyGl5eX3mHj6tWrKCoqQkhICCwtLbllVG1tbaioqEBbWxseeeQRuLq6gmVZJCQkYO3atdi7dy+mT5/ey8+UEEIoYBBCCCFGxbIsqqqqkJycDKlUihMnTiAoKAhisRgikQijRo26Y9hIS0sDwzAICQkBn8/v9LPW1lb89NNP+PLLL1FaWorw8HCMGDECBw8exG+//YZZs2YZ4+kRQggFDEIIIaSvsCyL2tpaLmwcPXoUAQEBXNgICAjgwsa3336LN954A4cPH0ZYWNhdHzc/Px/vvPMO9u/fDzMzM8yYMQMPPfQQ4uPj4e7uboynRggxYRQwCCGEkH6AZVk0NDRg9+7dkEqlOHz4MEaOHAmRSAQej4dPP/0U33zzDR566KEuHys5ORnPPvssdu7cieDgYCQnJyMpKQmnT5/G5MmT8dBDD+Ghhx6Cp6enEZ4ZIcTUUMAghBBC+iGFQoHffvsNW7duxZkzZyAUCvH4449DLBYjJCTkjn0x9u7diyeffBI//vgj4uPjO/2suroaKSkpSEpKwvHjx7F+/XqsW7fOGE+HEGJC9GsRSgghhNxg48aNiIyMhJ2dHQQCAcRiMYqKiu56n4SEBPB4vE7/WFlZGWnEA4+DgwOcnJyQm5uLX375BZ9//jkqKysxf/58BAYG4o033sCZM2fAMAx3n4MHD+Kpp57Cd999d0u4AAA3Nzc899xzOHLkCKqqqrBs2TJjPiVCiIm4tZ4dIYQQ0oXjx4/jxRdfRGRkJDQaDd58803MnTsXBQUFGDZs2B3vZ29v3ymIdLdMqyk5dOgQFi9ejO+//x6LFi0CADzyyCNoa2vDoUOHIJFI8OCDD2LYsGGIi4uDt7c33nvvPXz99dd4+OGHu3x8FxeX3n4KhBATRUukCCGE3LOamhoIBAIcP378jqVQExISsHr1ajQ2Nhp3cANQamoqRCIRduzYgUcfffSOxymVShw5cgRJSUn44YcfsHbtWrz33nsU3AghfYqWSBFCCLlnCoUCAG4pnXqzlpYWeHt7w9PTEyKRCPn5+cYY3oBSX1+PRYsWYfv27XcNFwBgZWWF2NhYJCQkoL6+Hu+88w6FC0JIn6MZDEIIIfeEYRjExcWhsbERJ0+evONxp0+fxqVLlxAUFASFQoGPPvoIJ06cQH5+PkaMGGHEEfd/FRUV8PLy6uthEEJIj1DAIIQQck+ef/55HDhwACdPnuxWUFCr1Rg7diyWLFmC9957rxdHSAghxJhokzchhJAeW7lyJfbu3YsTJ050exbCwsICoaGhKC4u7qXREUII6Qu0B4MQQki3sSyLlStXIjk5GUePHoWvr2+3H0Or1SI3N5c6SxNCyCBDMxiEEEK67cUXX8TPP/+M3bt3w87ODtXV1QCu926wtrYGACxduhQeHh7YuHEjAODdd9/F5MmT4efnh8bGRmzevBnl5eV45pln+ux5EEIIMTwKGIQQQrpt+/btAICZM2d2uv27777D8uXLAVzfqHxjt+mGhgb89a9/RXV1NZycnBAeHo5Tp05h3Lhxxho2IYQQI6BN3oQQQgghhBCDoT0YhBBCCCGEEIOhgEEIIYQQQggxGAoYhBBCCCGEEIOhgEEIIYQQQggxGAoYhBBCCCGEEIOhgEEIIYQQQggxGAoYhBBCCMG2bdvg4+MDKysrTJo0CWfPnr3r8YmJiQgICICVlRUCAwOxf/9+I42UENLfUcAghBBCTNyuXbuwZs0arF+/HpmZmQgODkZ0dDTkcvltjz916hSWLFmCp59+GllZWRCLxRCLxcjLyzPyyAkh/RE12iOEEEJM3KRJkxAZGYmtW7cCABiGgaenJ1atWoU33njjluMXL16M1tZW7N27l7tt8uTJCAkJwVdffWW0cRNC+ieawSCEEEJMmEqlQkZGBmbPns3dZmZmhtmzZ+P06dO3vc/p06c7HQ8A0dHRdzyeEGJaKGAQQgghJqy2thZarRZCobDT7UKhENXV1be9T3V1dbeOJ4SYFgoYhBBCCCGEEIOhgEEIIYSYMBcXF5ibm0Mmk3W6XSaTwc3N7bb3cXNz69bxhBDTQgGDEEIIMbDt27cjKCgI9vb2sLe3R1RUFA4cOHDX+/RV2VdLS0uEh4cjNTWVu41hGKSmpiIqKuq294mKiup0PAAcPnz4jscTQkwLBQxCCCHEwEaMGIF//etfyMjIQHp6Ou6//36IRCLk5+ff9vi+Lvu6Zs0afPvtt/j+++9x4cIFPP/882htbcWTTz4JAFi6dCnWrl3LHf/SSy/h4MGD+Pjjj1FYWIgNGzYgPT0dK1euNMp4CSH9G5WpJYQQQoyAz+dj8+bNePrpp2/5WX8o+7p161Zs3rwZ1dXVCAkJweeff45JkyYBAGbOnAkfHx8kJCRwxycmJmLdunUoKyuDv78/PvzwQyxYsMAoYyWE9G8UMAghhJBepNVqkZiYiGXLliErKwvjxo275RgvLy+sWbMGq1ev5m5bv349UlJSkJOTY8TREkLIvRvS1wMghBBCBqPc3FxERUVBqVTC1tYWycnJtw0XAJV9JYQMLrQHgxBCCOkFY8aMQXZ2Ns6cOYPnn38ey5YtQ0FBQV8PixBCeh3NYBBCCCG9wNLSEn5+fgCA8PBwnDt3Dp999hm+/vrrW46lsq+EkMGEZjAIIYQQI2AYBh0dHbf9GZV9JYQMJjSDQQghhBjY2rVrMX/+fHh5eaG5uRk///wz0tLScOjQIQDXy756eHhg48aNAK6XfZ0xYwY+/vhjxMTEYOfOnUhPT8c333zTl0+DEEJ6hAIGIYQQYmByuRxLly5FVVUVHBwcEBQUhEOHDmHOnDkAgIqKCpiZ/d8igilTpuDnn3/GunXr8Oabb8Lf3x8pKSmYMGFCXz0FQgjpMSpTSwghhBBCCDEY2oNBCCGEEEIIMRgKGIQQQgghhBCDoYBBCCGEEEIIMRgKGIQQQgghhBCDoYBBCCGEEEIIMRgKGIQQQgghhBCDoYBBCCGEEEIIMRgKGIQQQgghhBCDoYBBCCGEEEIIMRgKGIQQQgghhBCDoYBBCCGEEEIIMRgKGIQQQgghhBCDoYBBCCGEEEIIMRgKGIQQQgghhBCDoYBBCCGEEEIIMRgKGIQQQgghhBCDoYBBCCGEEEIIMRgKGIQQQgghhBCDoYBBCCGEEEIIMRgKGIQQQgghhBCDoYBBCCGEEEIIMRgKGIQQQgghhBCDoYBBCCGEEEIIMRgKGIQQQgghhBCDoYBBCCGEEEIIMRgKGIQQQgghhBCD+X8zgZY/nh9L7wAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 1000x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 加载模型并找到PDEs残差最大的质心点\n",
    "# 利用训练好的Pinns，计算NS方程的残差，并用残差大小对网格进行排序，选取一定比例的残差较大的网格进行离散\n",
    "mean = np.mean(xyz_and_labels, axis=0)  \n",
    "std = np.std(xyz_and_labels, axis=0) \n",
    "central_points =(central_points_origin - mean[:3]) / std[:3]\n",
    "# print(central_points.shape)\n",
    "# 选取约1/5的网格数进行加密\n",
    "num_mesh_to_refine =  central_points.shape[0] // 5\n",
    "central_points_tensor = paddle.to_tensor(central_points, dtype='float32')\n",
    "central_points_tensor.stop_gradient = False \n",
    "criterion = nn.MSELoss()\n",
    "pde_residuals = pinns.to_numpy(pinns.loss_pde_forward(Net, central_points_tensor))\n",
    "# print(pde_residuals.shape)\n",
    "index_in_tetrahedron = utils.find_ids_of_top_k(pde_residuals, num_mesh_to_refine)\n",
    "\n",
    "utils.plot_room_add_points_3d(central_points_origin[index_in_tetrahedron])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.1.5 网格优化\n",
    "算法思路：相似划分\n",
    "1. 对于每个四面体元素（tetrahedron element），考虑到优化后的网格与原网格要具有一定的相似性，这样可以保证新网格的质量，因此三维问题将网格的划分为2^3份。但直接对网格等分在三维问题的细化中不一定保证网格的质量，因此这里考虑对网格进行相似划分\n",
    "2. 为了将四面体网格相似划分，我们考虑其中的每条边，对于每条边，我们取中点，形成新的顶点。\n",
    "3. 新顶点与原四面体的四个顶点形成4个新的细分四面体，这些新四面体与原四面体相似。\n",
    "4. 剩下的一个八面体被等分为4个四面体，其中每个四面体的一个顶点是新的中点，其余三个顶点分别是原四面体的三个顶点。\n",
    "\n",
    "通过这个算法，我们可以将原始的四面体网格进行细分，得到更多的四面体元素，从而更精细地表示室内流动的几何形状和特征。\n",
    "\n",
    "这种细分算法可以用于生成更复杂的网格，以便更准确地模拟和分析室内流动的行为。然而，请注意，细分网格会增加计算和存储的复杂性，因此在实际应用中需要权衡计算资源和模拟精度之间的平衡。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### scipy.spatial.Delaunay优化网格\n",
    "1. 函数参数：\n",
    "class scipy.spatial.Delaunay(points, furthest_site=False, incremental=False, qhull_options=None)\n",
    "\n",
    "Delaunay tesselation in N dimensions.\n",
    "\n",
    "2. 参数解释：\n",
    "```\n",
    "points : ndarray of floats, shape (npoints, ndim)\n",
    "\n",
    "把点转化为三角形。\n",
    "\n",
    "furthest_site : bool, optional\n",
    "\n",
    "是否计算一个最远的Delaunay三角形，默认为否。这是版本 0.12.0.中的新参数。\n",
    "\n",
    "incremental : bool, optional\n",
    "\n",
    "增量地添加新点，需要额外的资源. \n",
    "\n",
    "qhull_options : str, optional\n",
    "\n",
    "Additional options to pass to Qhull. See Qhull manual for details. Option “Qt” is always enabled. Default:”Qbb Qc Qz Qx” for ndim > 4 and “Qbb Qc Qz” otherwise. Incremental mode omits “Qz”.。这是版本 0.12.0.中的新参数。\n",
    "```\n",
    "\n",
    "3. 单纯型 (simplex) 和三角剖分 (triangulation) ： \n",
    "单纯形是代数拓扑中最基本的概念。单纯形是三角形和四面体的一种泛化，一个k维单纯形是指包含 k+1个节点的凸多面体。人们希望能够把一个拓扑对象剖分成许多个小的单纯形，要求任何两个相邻的单纯形相交的公共部分仍是一个单纯形.这种剖分称为（曲）单纯剖分。在曲面情形，就是熟知的三角剖分。\n",
    "\n",
    "4. 一些属性\n",
    "```\n",
    "transform:\t从 x 到重心坐标 c 的仿射变换.\n",
    "vertex_to_simplex:\t查找数组, 从一个点找到它所在的单纯型\n",
    "convex_hull\t: 构成凸包的面状点集. Vertices of facets forming the convex hull of the point set.\n",
    "\n",
    "vertex_neighbor_vertices : 点的邻居节点\n",
    "\n",
    "points:\t(ndarray of double, shape (npoints, ndim)) 点集合\n",
    "simplices:\t(ndarray of ints, shape (nsimplex, ndim+1)) 构成单纯型的点的索引. 对二维来说，点是朝着逆时针方向的.\n",
    "neighbors:\t(ndarray of ints, shape (nsimplex, ndim+1)) 每个单纯型的邻居单纯型的索引. 第k个邻居位于第k个节点的相反方向. 对于边界单纯型, -1表示无邻居.\n",
    "equations: (ndarray of double, shape (nsimplex, ndim+2)) [normal, offset] 构成抛物面上的小面的超平面方程\n",
    "\n",
    "paraboloid_scale, paraboloid_shift\t(float) 额外抛物面维度的范围、移动\n",
    "coplanar\t(ndarray of int, shape (ncoplanar, 3)) 共面点的索引 and the 最近共面和最近点的索引. 共面点是输入点，由于数值精度问题不在三角划分中.\n",
    "vertices: 和simplices相似\n",
    "```\n",
    "\n",
    "5. 方法：\n",
    "- add_points(points[, restart])\t增加新点\n",
    "- close()\t完成增量过程\n",
    "- find_simplex(self, xi[, bruteforce, tol])\t找到包含指定点的单纯型\n",
    "- lift_points(self, x)\t\n",
    "- Lift points to the Qhull paraboloid. 指向Qhull抛物面的升力点\n",
    "- plane_distance(self, xi)\t计算点 xi 到所有单纯型的超平面距离"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-12-01T14:14:07.940820Z",
     "iopub.status.busy": "2023-12-01T14:14:07.940224Z",
     "iopub.status.idle": "2023-12-01T14:14:08.235951Z",
     "shell.execute_reply": "2023-12-01T14:14:08.234765Z",
     "shell.execute_reply.started": "2023-12-01T14:14:07.940789Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# index_in_tetrahedron = index_top_t\n",
    "refine_tets = tetrahedrons[index_in_tetrahedron]\n",
    "new_points_half_edge = utils.tetrahedron_midpoint(refine_tets, vertices)\n",
    "new_points_half_edge = np.unique(new_points_half_edge, axis=0)\n",
    " \n",
    "#Delaunay tetrahedralization of the new mesh\n",
    "refined_tet = Delaunay(np.vstack((vertices, new_points_half_edge)), furthest_site=False, incremental=False, qhull_options=None)\n",
    "info_new = MeshInfo()\n",
    "info_new.set_points(refined_tet.points)\n",
    "info_new.set_facets(refined_tet.convex_hull)\n",
    "refined_mesh = build(info_new, options=Options(\"p\"))\n",
    "if tag_train:\n",
    "    # outputs it as a VTK file.\n",
    "    refined_mesh.write_vtk(f\"work/progress/{level_next}/mesh_files/{level_next}.vtk\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## level 2-4\n",
    "重复上述过程，以下为代码"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### level 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-12-01T14:19:46.614797Z",
     "iopub.status.busy": "2023-12-01T14:19:46.614178Z",
     "iopub.status.idle": "2023-12-01T14:19:57.694186Z",
     "shell.execute_reply": "2023-12-01T14:19:57.693041Z",
     "shell.execute_reply.started": "2023-12-01T14:19:46.614754Z"
    },
    "scrolled": true,
    "tags": []
   },
   "outputs": [],
   "source": [
    "level, level_next = 'level_02', 'level_03'\n",
    "# read mesh form the last vtk file\n",
    "mesh = meshio.read(f'work/progress/{level}/mesh_files/{level}.vtk', file_format='vtk')\n",
    "points = mesh.points\n",
    "# Delaunay tetrahedralization\n",
    "# points Enter scatter points; furthest_site is True to compute the furthest point; incremental is True to allow incremental addition of points; qhull_options is the qhull parameter\n",
    "tri = Delaunay(points, furthest_site=False, incremental=False, qhull_options=None)\n",
    "# get vertices and tetrahedrons\n",
    "vertices = tri.points\n",
    "tetrahedrons = tri.simplices\n",
    "# find the center point in each tetrahedron\n",
    "central_points_origin = utils.find_center_in_tetrahedron(tetrahedrons, vertices)\n",
    "\n",
    "# read data from cfd result\n",
    "datas_from_cfd = pd.read_csv(f'work/progress/{level}/cfd_labels/{level}_labels_from_cfd.dat').values\n",
    "# x, y, p, rho, u, v = np.array([datas_from_cfd[:,i+1] for i in range(6)])\n",
    "xyz_and_labels = datas_from_cfd[:,1:]\n",
    "x_pde_train, label = utils.to_tensor(xyz_and_labels)\n",
    "# model\n",
    "Net = pinns.DNN_single(depth=4, width=40, active = nn.Tanh())\n",
    "# we use adam opt, with deacy learning rate from 1e-3. cosine annealing strategies to dynamically adjust the learning rate. The deatils see work.src.pinns\n",
    "if tag_train:\n",
    "    pinns.train(Net, x_pde_train,label, best_loss=1e2, opt = 'Adam', epoches=200000, lr=1e-3, step=1, progress_path=f'work/progress/{level}')\n",
    "else:\n",
    "    Net.loadmodel(f\"work/progress/{level}/model_paras/ns.pdparams\")\n",
    "\n",
    "'''visualize the velocity and pressure using neural network'''\n",
    "pinns.show_slice_uvwp(Net, xyz_and_labels)\n",
    "# 加载模型并找到PDEs残差最大的质心点\n",
    "# 利用训练好的Pinns，计算NS方程的残差，并用残差大小对网格进行排序，选取一定比例的残差较大的网格进行离散\n",
    "mean = np.mean(xyz_and_labels, axis=0)  \n",
    "std = np.std(xyz_and_labels, axis=0) \n",
    "central_points =(central_points_origin - mean[:3]) / std[:3]\n",
    "# print(central_points.shape)\n",
    "# 选取约1/5的网格数进行加密\n",
    "num_mesh_to_refine =  central_points.shape[0] // 5\n",
    "central_points_tensor = paddle.to_tensor(central_points, dtype='float32')\n",
    "central_points_tensor.stop_gradient = False \n",
    "criterion = nn.MSELoss()\n",
    "pde_residuals = pinns.to_numpy(pinns.loss_pde_forward(Net, central_points_tensor))\n",
    "# print(pde_residuals.shape)\n",
    "index_in_tetrahedron = utils.find_ids_of_top_k(pde_residuals, num_mesh_to_refine)\n",
    "\n",
    "utils.plot_room_add_points_3d(central_points_origin[index_in_tetrahedron])\n",
    "\n",
    "# index_in_tetrahedron = index_top_t\n",
    "refine_tets = tetrahedrons[index_in_tetrahedron]\n",
    "new_points_half_edge = utils.tetrahedron_midpoint(refine_tets, vertices)\n",
    "new_points_half_edge = np.unique(new_points_half_edge, axis=0)\n",
    " \n",
    "#Delaunay tetrahedralization of the new mesh\n",
    "refined_tet = Delaunay(np.vstack((vertices, new_points_half_edge)), furthest_site=False, incremental=False, qhull_options=None)\n",
    "info_new = MeshInfo()\n",
    "info_new.set_points(refined_tet.points)\n",
    "info_new.set_facets(refined_tet.convex_hull)\n",
    "refined_mesh = build(info_new, options=Options(\"p\"))\n",
    "if tag_train:\n",
    "    # outputs it as a VTK file.\n",
    "    refined_mesh.write_vtk(f\"work/progress/{level_next}/mesh_files/{level_next}.vtk\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-12-01T14:20:11.019688Z",
     "iopub.status.busy": "2023-12-01T14:20:11.018885Z",
     "iopub.status.idle": "2023-12-01T14:20:33.979507Z",
     "shell.execute_reply": "2023-12-01T14:20:33.978404Z",
     "shell.execute_reply.started": "2023-12-01T14:20:11.019656Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "level, level_next = 'level_03', 'level_04'\n",
    "# read mesh form the last vtk file\n",
    "mesh = meshio.read(f'work/progress/{level}/mesh_files/{level}.vtk', file_format='vtk')\n",
    "points = mesh.points\n",
    "# Delaunay tetrahedralization\n",
    "# points Enter scatter points; furthest_site is True to compute the furthest point; incremental is True to allow incremental addition of points; qhull_options is the qhull parameter\n",
    "tri = Delaunay(points, furthest_site=False, incremental=False, qhull_options=None)\n",
    "# get vertices and tetrahedrons\n",
    "vertices = tri.points\n",
    "tetrahedrons = tri.simplices\n",
    "# find the center point in each tetrahedron\n",
    "central_points_origin = utils.find_center_in_tetrahedron(tetrahedrons, vertices)\n",
    "\n",
    "# read data from cfd result\n",
    "datas_from_cfd = pd.read_csv(f'work/progress/{level}/cfd_labels/{level}_labels_from_cfd.dat').values\n",
    "# x, y, p, rho, u, v = np.array([datas_from_cfd[:,i+1] for i in range(6)])\n",
    "xyz_and_labels = datas_from_cfd[:,1:]\n",
    "x_pde_train, label = utils.to_tensor(xyz_and_labels)\n",
    "# model\n",
    "Net = pinns.DNN_single(depth=4, width=40, active = nn.Tanh())\n",
    "# we use adam opt, with deacy learning rate from 1e-3. cosine annealing strategies to dynamically adjust the learning rate. The deatils see work.src.pinns\n",
    "if tag_train:\n",
    "    pinns.train(Net, x_pde_train,label, best_loss=1e2, opt = 'Adam', epoches=200000, lr=1e-3, step=1, progress_path=f'work/progress/{level}')\n",
    "else:\n",
    "    Net.loadmodel(f\"work/progress/{level}/model_paras/ns.pdparams\")\n",
    "\n",
    "'''visualize the velocity and pressure using neural network'''\n",
    "\n",
    "pinns.show_slice_uvwp(Net, xyz_and_labels)\n",
    "\n",
    "\n",
    "# 加载模型并找到PDEs残差最大的质心点\n",
    "# 利用训练好的Pinns，计算NS方程的残差，并用残差大小对网格进行排序，选取一定比例的残差较大的网格进行离散\n",
    "mean = np.mean(xyz_and_labels, axis=0)  \n",
    "std = np.std(xyz_and_labels, axis=0) \n",
    "central_points =(central_points_origin - mean[:3]) / std[:3]\n",
    "# print(central_points.shape)\n",
    "# 选取约1/5的网格数进行加密\n",
    "num_mesh_to_refine =  central_points.shape[0] // 5\n",
    "central_points_tensor = paddle.to_tensor(central_points, dtype='float32')\n",
    "central_points_tensor.stop_gradient = False \n",
    "criterion = nn.MSELoss()\n",
    "pde_residuals = pinns.to_numpy(pinns.loss_pde_forward(Net, central_points_tensor))\n",
    "# print(pde_residuals.shape)\n",
    "index_in_tetrahedron = utils.find_ids_of_top_k(pde_residuals, num_mesh_to_refine)\n",
    "\n",
    "utils.plot_room_add_points_3d(central_points_origin[index_in_tetrahedron])\n",
    "\n",
    "# index_in_tetrahedron = index_top_t\n",
    "refine_tets = tetrahedrons[index_in_tetrahedron]\n",
    "new_points_half_edge = utils.tetrahedron_midpoint(refine_tets, vertices)\n",
    "new_points_half_edge = np.unique(new_points_half_edge, axis=0)\n",
    " \n",
    "#Delaunay tetrahedralization of the new mesh\n",
    "refined_tet = Delaunay(np.vstack((vertices, new_points_half_edge)), furthest_site=False, incremental=False, qhull_options=None)\n",
    "info_new = MeshInfo()\n",
    "info_new.set_points(refined_tet.points)\n",
    "info_new.set_facets(refined_tet.convex_hull)\n",
    "refined_mesh = build(info_new, options=Options(\"p\"))\n",
    "if tag_train:\n",
    "    # outputs it as a VTK file.\n",
    "    refined_mesh.write_vtk(f\"work/progress/{level_next}/mesh_files/{level_next}.vtk\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-12-01T14:25:54.519970Z",
     "iopub.status.busy": "2023-12-01T14:25:54.519289Z"
    },
    "scrolled": true,
    "tags": []
   },
   "outputs": [],
   "source": [
    "level, level_next = 'level_04', 'level_05'\n",
    "# read mesh form the last vtk file\n",
    "mesh = meshio.read(f'work/progress/{level}/mesh_files/{level}.vtk', file_format='vtk')\n",
    "points = mesh.points\n",
    "# Delaunay tetrahedralization\n",
    "# points Enter scatter points; furthest_site is True to compute the furthest point; incremental is True to allow incremental addition of points; qhull_options is the qhull parameter\n",
    "tri = Delaunay(points, furthest_site=False, incremental=False, qhull_options=None)\n",
    "# get vertices and tetrahedrons\n",
    "vertices = tri.points\n",
    "tetrahedrons = tri.simplices\n",
    "# find the center point in each tetrahedron\n",
    "central_points_origin = utils.find_center_in_tetrahedron(tetrahedrons, vertices)\n",
    "\n",
    "# read data from cfd result\n",
    "datas_from_cfd = pd.read_csv(f'work/progress/{level}/cfd_labels/{level}_labels_from_cfd.dat').values\n",
    "# x, y, p, rho, u, v = np.array([datas_from_cfd[:,i+1] for i in range(6)])\n",
    "xyz_and_labels = datas_from_cfd[:,1:]\n",
    "x_pde_train, label = utils.to_tensor(xyz_and_labels)\n",
    "# model\n",
    "Net = pinns.DNN_single(depth=4, width=40, active = nn.Tanh())\n",
    "# we use adam opt, with deacy learning rate from 1e-3. cosine annealing strategies to dynamically adjust the learning rate. The deatils see work.src.pinns\n",
    "if tag_train:\n",
    "    pinns.train(Net, x_pde_train,label, best_loss=1e2, opt = 'Adam', epoches=200000, lr=1e-3, step=1, progress_path=f'work/progress/{level}')\n",
    "else:\n",
    "    Net.loadmodel(f\"work/progress/{level}/model_paras/ns.pdparams\")\n",
    "\n",
    "'''visualize the velocity and pressure using neural network'''\n",
    "pinns.show_slice_uvwp(Net, xyz_and_labels)\n",
    "# 加载模型并找到PDEs残差最大的质心点\n",
    "# 利用训练好的Pinns，计算NS方程的残差，并用残差大小对网格进行排序，选取一定比例的残差较大的网格进行离散\n",
    "mean = np.mean(xyz_and_labels, axis=0)  \n",
    "std = np.std(xyz_and_labels, axis=0) \n",
    "central_points =(central_points_origin - mean[:3]) / std[:3]\n",
    "# print(central_points.shape)\n",
    "# 选取约1/5的网格数进行加密\n",
    "num_mesh_to_refine =  central_points.shape[0] // 5\n",
    "central_points_tensor = paddle.to_tensor(central_points, dtype='float32')\n",
    "central_points_tensor.stop_gradient = False \n",
    "criterion = nn.MSELoss()\n",
    "pde_residuals = pinns.to_numpy(pinns.loss_pde_forward(Net, central_points_tensor))\n",
    "# print(pde_residuals.shape)\n",
    "index_in_tetrahedron = utils.find_ids_of_top_k(pde_residuals, num_mesh_to_refine)\n",
    "\n",
    "utils.plot_room_add_points_3d(central_points_origin[index_in_tetrahedron])\n",
    "\n",
    "# index_in_tetrahedron = index_top_t\n",
    "refine_tets = tetrahedrons[index_in_tetrahedron]\n",
    "new_points_half_edge = utils.tetrahedron_midpoint(refine_tets, vertices)\n",
    "new_points_half_edge = np.unique(new_points_half_edge, axis=0)\n",
    " \n",
    "#Delaunay tetrahedralization of the new mesh\n",
    "refined_tet = Delaunay(np.vstack((vertices, new_points_half_edge)), furthest_site=False, incremental=False, qhull_options=None)\n",
    "info_new = MeshInfo()\n",
    "info_new.set_points(refined_tet.points)\n",
    "info_new.set_facets(refined_tet.convex_hull)\n",
    "refined_mesh = build(info_new, options=Options(\"p\"))\n",
    "if tag_train:\n",
    "    # outputs it as a VTK file.\n",
    "    refined_mesh.write_vtk(f\"work/progress/{level_next}/mesh_files/{level_next}.vtk\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 四、评估与总结\n",
    "### 4.1 评估指标\n",
    "根据官方要求，我们需要对室内高度方向中心面及长度方向中心面交线的速度幅值（长度方向为出风口吹气方向）进行评估。为了更好的评估和量化我们的结构，我们选取两条垂直的线段上的最大速度来评估本方案。如图所示：\n",
    "\n",
    "![](https://ai-studio-static-online.cdn.bcebos.com/b89d8a24d2b24ec69cfe639e1cf219b45c255c77f52645aa84087dba27743c62)\n",
    "\n",
    "红色的两条线段分别连接进风口与出风口，从优化过程可以看出，进风口与出风口的速度是比较大的，也需要得到更大的关注。\n",
    "\n",
    "最终的优化结构与CFD对比如图所示：\n",
    "\n",
    "![](https://ai-studio-static-online.cdn.bcebos.com/8610f8d95c924d83a22bba87bc64615e21c12760556f4ca98d4cea9fa58889ef)\n",
    "\n",
    "### 4.2 定量分析\n",
    "我们的最优网格为level 3的代码，加密后的速度满足要求。误差在0.2%以内。\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "py35-paddle1.2.0"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
